src/chrome/browser/extensions/api/media_galleries_private/media_galleries_watch_apitest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4 //
   5 // MediaGalleriesPrivate gallery watch API browser tests.
   6
   7 #include "base/file_util.h"
   8 #include "base/files/file_path.h"
   9 #include "base/path_service.h"
  10 #include "base/strings/utf_string_conversions.h"
  11 #include "build/build_config.h"
  12 #include "chrome/browser/extensions/extension_apitest.h"
  13 #include "chrome/browser/extensions/extension_service.h"
  14 #include "chrome/browser/extensions/extension_system.h"
  15 #include "chrome/browser/extensions/extension_test_message_listener.h"
  16 #include "chrome/browser/media_galleries/media_galleries_test_util.h"
  17 #include "chrome/common/chrome_paths.h"
  18 #include "chrome/common/chrome_switches.h"
  19 #include "chrome/common/extensions/extension.h"
  20 #include "content/public/browser/render_view_host.h"
  21
  22 namespace {
  23
  24 // Id of test extension from
  25 // chrome/test/data/extensions/api_test/|kTestExtensionPath|
  26 const char kTestExtensionId[] = "gceegfkgibmgpfopknlcgleimclbknie";
  27 const char kTestExtensionPath[] = "media_galleries_private/gallerywatch";
  28
  29 #if !defined(OS_CHROMEOS)
  30 // JS commands.
  31 const char kGetAllWatchedGalleryIdsCmd[] = "getAllWatchedGalleryIds()";
  32 const char kGetMediaFileSystemsCmd[] = "getMediaFileSystems()";
  33 const char kSetupWatchOnValidGalleriesCmd[] = "setupWatchOnValidGalleries()";
  34 #if defined(OS_WIN)
  35 const char kAddGalleryChangedListenerCmd[] = "addGalleryChangedListener()";
  36 const char kRemoveAllGalleryWatchCmd[] = "removeAllGalleryWatch()";
  37 const char kRemoveGalleryChangedListenerCmd[] =
  38     "removeGalleryChangedListener()";
  39 const char kRemoveGalleryWatchCmd[] = "removeGalleryWatch()";
  40 const char kSetupWatchOnInvalidGalleryCmd[] = "setupWatchOnInvalidGallery()";
  41 #endif  // defined(OS_WIN)
  42
  43 // And JS reply messages.
  44 const char kAddGalleryWatchOK[] = "add_gallery_watch_ok";
  45 const char kGetAllGalleryWatchOK[] = "get_all_gallery_watch_ok";
  46 const char kGetMediaFileSystemsCallbackOK[] =
  47     "get_media_file_systems_callback_ok";
  48 const char kGetMediaFileSystemsOK[] = "get_media_file_systems_ok";
  49 #if defined(OS_WIN)
  50 const char kAddGalleryChangedListenerOK[] = "add_gallery_changed_listener_ok";
  51 const char kRemoveAllGalleryWatchOK[] = "remove_all_gallery_watch_ok";
  52 const char kRemoveGalleryChangedListenerOK[] =
  53     "remove_gallery_changed_listener_ok";
  54 const char kRemoveGalleryWatchOK[] = "remove_gallery_watch_ok";
  55 #endif  // defined(OS_WIN)
  56
  57 // Test reply messages.
  58 const char kGetAllGalleryWatchResultA[] = "gallery_watchers_does_not_exists";
  59 const char kAddGalleryWatchRequestFailed[] = "add_watch_request_failed";
  60 #if defined(OS_WIN)
  61 const char kAddGalleryWatchRequestSucceeded[] = "add_watch_request_succeeded";
  62 const char kGalleryChangedEventReceived[] = "gallery_changed_event_received";
  63 const char kGetAllGalleryWatchResultB[] =
  64     "watchers_for_galleries_{1, 2, 3}_found";
  65 #endif  // defined(OS_WIN)
  66 #endif  // !defined(OS_CHROMEOS)
  67
  68 }  // namespace
  69
  70
  71 ///////////////////////////////////////////////////////////////////////////////
  72 //                 MediaGalleriesPrivateGalleryWatchApiTest                  //
  73 ///////////////////////////////////////////////////////////////////////////////
  74
  75 class MediaGalleriesPrivateGalleryWatchApiTest : public ExtensionApiTest {
  76  public:
  77   MediaGalleriesPrivateGalleryWatchApiTest() {}
  78   virtual ~MediaGalleriesPrivateGalleryWatchApiTest() {}
  79
  80  protected:
  81   // ExtensionApiTest overrides.
  82   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
  83     ExtensionApiTest::SetUpCommandLine(command_line);
  84     command_line->AppendSwitchASCII(switches::kWhitelistedExtensionID,
  85                                     kTestExtensionId);
  86   }
  87
  88   void ExecuteCmdAndCheckReply(content::RenderViewHost* host,
  89                               const std::string& js_command,
  90                               const std::string& ok_message) {
  91     ExtensionTestMessageListener listener(ok_message, false);
  92     host->ExecuteJavascriptInWebFrame(string16(), ASCIIToUTF16(js_command));
  93     EXPECT_TRUE(listener.WaitUntilSatisfied());
  94   }
  95
  96   bool AddNewFileInGallery(int gallery_directory_key) {
  97     if ((gallery_directory_key != chrome::DIR_USER_MUSIC) &&
  98         (gallery_directory_key != chrome::DIR_USER_PICTURES) &&
  99         (gallery_directory_key != chrome::DIR_USER_VIDEOS))
 100       return false;
 101
 102     base::FilePath gallery_dir;
 103     if (!PathService::Get(gallery_directory_key, &gallery_dir))
 104       return false;
 105     base::FilePath gallery_file =
 106         gallery_dir.Append(FILE_PATH_LITERAL("test1.txt"));
 107     std::string content("new content");
 108     int write_size = file_util::WriteFile(gallery_file, content.c_str(),
 109                                           content.length());
 110     return (write_size == static_cast<int>(content.length()));
 111   }
 112
 113   // Loads the test extension and returns the RenderViewHost of the extension.
 114   // Returns NULL if the extension load operation failed.
 115   content::RenderViewHost* GetBackgroundHostForTestExtension() {
 116     const extensions::Extension* extension =
 117         LoadExtension(test_data_dir_.AppendASCII(kTestExtensionPath));
 118     if (!extension)
 119       return NULL;
 120     return extensions::ExtensionSystem::Get(browser()->profile())->
 121         process_manager()->GetBackgroundHostForExtension(extension->id())->
 122            render_view_host();
 123   }
 124
 125  private:
 126   DISALLOW_COPY_AND_ASSIGN(MediaGalleriesPrivateGalleryWatchApiTest);
 127 };
 128
 129
 130 ///////////////////////////////////////////////////////////////////////////////
 131 //                               TESTS                                       //
 132 ///////////////////////////////////////////////////////////////////////////////
 133 #if defined(OS_WIN)
 134 IN_PROC_BROWSER_TEST_F(MediaGalleriesPrivateGalleryWatchApiTest,
 135                        BasicGalleryWatch) {
 136   EnsureMediaDirectoriesExists media_directories;
 137   content::RenderViewHost* host = GetBackgroundHostForTestExtension();
 138   ASSERT_TRUE(host);
 139
 140   // Get media file systems.
 141   ExtensionTestMessageListener get_media_systems_finished(
 142       kGetMediaFileSystemsCallbackOK, false  /* no reply */);
 143   ExecuteCmdAndCheckReply(host, kGetMediaFileSystemsCmd,
 144                           kGetMediaFileSystemsOK);
 145   EXPECT_TRUE(get_media_systems_finished.WaitUntilSatisfied());
 146
 147   // Set up gallery watch.
 148   ExtensionTestMessageListener add_gallery_watch_finished(
 149       kAddGalleryWatchRequestSucceeded, false  /* no reply */);
 150   ExecuteCmdAndCheckReply(host, kSetupWatchOnValidGalleriesCmd,
 151                           kAddGalleryWatchOK);
 152   EXPECT_TRUE(add_gallery_watch_finished.WaitUntilSatisfied());
 153
 154   // Add gallery watch listener.
 155   ExecuteCmdAndCheckReply(host, kAddGalleryChangedListenerCmd,
 156                           kAddGalleryChangedListenerOK);
 157
 158   // Modify gallery contents.
 159   ExtensionTestMessageListener music_gallery_change_event_received(
 160       kGalleryChangedEventReceived, false  /* no reply */);
 161   ASSERT_TRUE(AddNewFileInGallery(chrome::DIR_USER_MUSIC));
 162   EXPECT_TRUE(music_gallery_change_event_received.WaitUntilSatisfied());
 163
 164   ExtensionTestMessageListener pictures_gallery_change_event_received(
 165       kGalleryChangedEventReceived, false  /* no reply */);
 166   ASSERT_TRUE(AddNewFileInGallery(chrome::DIR_USER_PICTURES));
 167   EXPECT_TRUE(pictures_gallery_change_event_received.WaitUntilSatisfied());
 168
 169   ExtensionTestMessageListener videos_gallery_change_event_received(
 170       kGalleryChangedEventReceived, false  /* no reply */);
 171   ASSERT_TRUE(AddNewFileInGallery(chrome::DIR_USER_VIDEOS));
 172   EXPECT_TRUE(videos_gallery_change_event_received.WaitUntilSatisfied());
 173
 174   // Remove gallery watch listener.
 175   ExecuteCmdAndCheckReply(host, kRemoveGalleryChangedListenerCmd,
 176                           kRemoveGalleryChangedListenerOK);
 177
 178   // Remove gallery watch request.
 179   ExecuteCmdAndCheckReply(host, kRemoveGalleryWatchCmd, kRemoveGalleryWatchOK);
 180 }
 181
 182 IN_PROC_BROWSER_TEST_F(MediaGalleriesPrivateGalleryWatchApiTest,
 183                        RemoveListenerAndModifyGallery) {
 184   EnsureMediaDirectoriesExists media_directories;
 185   content::RenderViewHost* host = GetBackgroundHostForTestExtension();
 186   ASSERT_TRUE(host);
 187
 188   // Get media file systems.
 189   ExtensionTestMessageListener get_media_systems_finished(
 190       kGetMediaFileSystemsCallbackOK, false  /* no reply */);
 191   ExecuteCmdAndCheckReply(host, kGetMediaFileSystemsCmd,
 192                           kGetMediaFileSystemsOK);
 193   EXPECT_TRUE(get_media_systems_finished.WaitUntilSatisfied());
 194
 195   // Set up gallery watch.
 196   ExtensionTestMessageListener add_gallery_watch_finished(
 197       kAddGalleryWatchRequestSucceeded, false  /* no reply */);
 198   ExecuteCmdAndCheckReply(host, kSetupWatchOnValidGalleriesCmd,
 199                          kAddGalleryWatchOK);
 200   EXPECT_TRUE(add_gallery_watch_finished.WaitUntilSatisfied());
 201
 202   // Add a gallery watch listener.
 203   ExecuteCmdAndCheckReply(host, kAddGalleryChangedListenerCmd,
 204                           kAddGalleryChangedListenerOK);
 205   // Modify gallery contents.
 206   ExtensionTestMessageListener music_gallery_change_event_received(
 207       kGalleryChangedEventReceived, false  /* no reply */);
 208   ASSERT_TRUE(AddNewFileInGallery(chrome::DIR_USER_MUSIC));
 209   EXPECT_TRUE(music_gallery_change_event_received.WaitUntilSatisfied());
 210
 211   // Remove gallery watch listener.
 212   ExecuteCmdAndCheckReply(host, kRemoveGalleryChangedListenerCmd,
 213                           kRemoveGalleryChangedListenerOK);
 214
 215   // No listener, modify gallery contents.
 216   ASSERT_TRUE(AddNewFileInGallery(chrome::DIR_USER_MUSIC));
 217
 218   // Remove gallery watch.
 219   ExecuteCmdAndCheckReply(host, kRemoveGalleryWatchCmd, kRemoveGalleryWatchOK);
 220 }
 221
 222 IN_PROC_BROWSER_TEST_F(MediaGalleriesPrivateGalleryWatchApiTest,
 223                        SetupGalleryWatchWithoutListeners) {
 224   EnsureMediaDirectoriesExists media_directories;
 225   content::RenderViewHost* host = GetBackgroundHostForTestExtension();
 226   ASSERT_TRUE(host);
 227
 228   // Get media file systems.
 229   ExtensionTestMessageListener get_media_systems_finished(
 230       kGetMediaFileSystemsCallbackOK, false  /* no reply */);
 231   ExecuteCmdAndCheckReply(host, kGetMediaFileSystemsCmd,
 232                           kGetMediaFileSystemsOK);
 233   EXPECT_TRUE(get_media_systems_finished.WaitUntilSatisfied());
 234
 235   // Set up gallery watch.
 236   ExecuteCmdAndCheckReply(host, kSetupWatchOnValidGalleriesCmd,
 237                           kAddGalleryWatchOK);
 238
 239   // No listeners, modify gallery contents.
 240   ExtensionTestMessageListener music_gallery_change_event_received(
 241       kGalleryChangedEventReceived, false  /* no reply */);
 242   ASSERT_TRUE(AddNewFileInGallery(chrome::DIR_USER_MUSIC));
 243
 244   // Remove gallery watch.
 245   ExecuteCmdAndCheckReply(host, kRemoveGalleryWatchCmd, kRemoveGalleryWatchOK);
 246 }
 247
 248 IN_PROC_BROWSER_TEST_F(MediaGalleriesPrivateGalleryWatchApiTest,
 249                        SetupGalleryChangedListenerWithoutWatchers) {
 250   EnsureMediaDirectoriesExists media_directories;
 251   content::RenderViewHost* host = GetBackgroundHostForTestExtension();
 252   ASSERT_TRUE(host);
 253
 254   // Get media file systems.
 255   ExtensionTestMessageListener get_media_systems_finished(
 256       kGetMediaFileSystemsCallbackOK, false  /* no reply */);
 257   ExecuteCmdAndCheckReply(host, kGetMediaFileSystemsCmd,
 258                           kGetMediaFileSystemsOK);
 259   EXPECT_TRUE(get_media_systems_finished.WaitUntilSatisfied());
 260
 261   // Add gallery watch listener.
 262   ExecuteCmdAndCheckReply(host, kAddGalleryChangedListenerCmd,
 263                           kAddGalleryChangedListenerOK);
 264
 265   // Modify gallery contents. Listener should not get called because add watch
 266   // request was not called.
 267   ExtensionTestMessageListener music_gallery_change_event_received(
 268       kGalleryChangedEventReceived, false  /* no reply */);
 269   ASSERT_TRUE(AddNewFileInGallery(chrome::DIR_USER_MUSIC));
 270
 271   // Remove gallery watch listener.
 272   ExecuteCmdAndCheckReply(host, kRemoveGalleryChangedListenerCmd,
 273                           kRemoveGalleryChangedListenerOK);
 274 }
 275
 276 IN_PROC_BROWSER_TEST_F(MediaGalleriesPrivateGalleryWatchApiTest,
 277                        SetupWatchOnInvalidGallery) {
 278   content::RenderViewHost* host = GetBackgroundHostForTestExtension();
 279   ASSERT_TRUE(host);
 280
 281   // Set up a invalid gallery watch.
 282   ExtensionTestMessageListener invalid_gallery_watch_request_finished(
 283       kAddGalleryWatchRequestFailed, false  /* no reply */);
 284   ExecuteCmdAndCheckReply(host, kSetupWatchOnInvalidGalleryCmd,
 285                           kAddGalleryWatchOK);
 286   EXPECT_TRUE(invalid_gallery_watch_request_finished.WaitUntilSatisfied());
 287 }
 288
 289 IN_PROC_BROWSER_TEST_F(MediaGalleriesPrivateGalleryWatchApiTest,
 290                        GetAllGalleryWatch) {
 291   EnsureMediaDirectoriesExists media_directories;
 292   content::RenderViewHost* host = GetBackgroundHostForTestExtension();
 293   ASSERT_TRUE(host);
 294
 295   // Get media file systems.
 296   ExtensionTestMessageListener get_media_systems_finished(
 297       kGetMediaFileSystemsCallbackOK, false  /* no reply */);
 298   ExecuteCmdAndCheckReply(host, kGetMediaFileSystemsCmd,
 299                           kGetMediaFileSystemsOK);
 300   EXPECT_TRUE(get_media_systems_finished.WaitUntilSatisfied());
 301
 302   // Gallery watchers are not yet added.
 303   // chrome.mediaGalleriesPrivate.getAllGalleryWatch should return an empty
 304   // list.
 305   ExtensionTestMessageListener initial_get_all_check_finished(
 306       kGetAllGalleryWatchResultA, false  /* no reply */);
 307   ExecuteCmdAndCheckReply(host, kGetAllWatchedGalleryIdsCmd,
 308                           kGetAllGalleryWatchOK);
 309   EXPECT_TRUE(initial_get_all_check_finished.WaitUntilSatisfied());
 310
 311   // Set up gallery watchers.
 312   ExtensionTestMessageListener add_gallery_watch_finished(
 313       kAddGalleryWatchRequestSucceeded, false  /* no reply */);
 314   ExecuteCmdAndCheckReply(host, kSetupWatchOnValidGalleriesCmd,
 315                           kAddGalleryWatchOK);
 316   EXPECT_TRUE(add_gallery_watch_finished.WaitUntilSatisfied());
 317
 318   // chrome.mediaGalleriesPrivate.getAllGalleryWatch should return the
 319   // gallery identifiers.
 320   ExtensionTestMessageListener get_all_watched_galleries_finished(
 321       kGetAllGalleryWatchResultB, false  /* no reply */);
 322   ExecuteCmdAndCheckReply(host, kGetAllWatchedGalleryIdsCmd,
 323                           kGetAllGalleryWatchOK);
 324   EXPECT_TRUE(get_all_watched_galleries_finished.WaitUntilSatisfied());
 325
 326   // Remove gallery watch request.
 327   ExecuteCmdAndCheckReply(host, kRemoveGalleryWatchCmd, kRemoveGalleryWatchOK);
 328
 329   // Gallery watchers removed.
 330   // chrome.mediaGalleriesPrivate.getAllGalleryWatch() should return an empty
 331   // list.
 332   ExtensionTestMessageListener final_get_all_check_finished(
 333       kGetAllGalleryWatchResultA, false  /* no reply */);
 334   ExecuteCmdAndCheckReply(host, kGetAllWatchedGalleryIdsCmd,
 335                           kGetAllGalleryWatchOK);
 336   EXPECT_TRUE(final_get_all_check_finished.WaitUntilSatisfied());
 337 }
 338
 339 IN_PROC_BROWSER_TEST_F(MediaGalleriesPrivateGalleryWatchApiTest,
 340                        RemoveAllGalleryWatch) {
 341   EnsureMediaDirectoriesExists media_directories;
 342   content::RenderViewHost* host = GetBackgroundHostForTestExtension();
 343   ASSERT_TRUE(host);
 344
 345   // Get media file systems.
 346   ExtensionTestMessageListener get_media_systems_finished(
 347       kGetMediaFileSystemsCallbackOK, false  /* no reply */);
 348   ExecuteCmdAndCheckReply(host, kGetMediaFileSystemsCmd,
 349                           kGetMediaFileSystemsOK);
 350   EXPECT_TRUE(get_media_systems_finished.WaitUntilSatisfied());
 351
 352   // Set up gallery watchers.
 353   ExtensionTestMessageListener add_gallery_watch_finished(
 354       kAddGalleryWatchRequestSucceeded, false  /* no reply */);
 355   ExecuteCmdAndCheckReply(host, kSetupWatchOnValidGalleriesCmd,
 356                           kAddGalleryWatchOK);
 357   EXPECT_TRUE(add_gallery_watch_finished.WaitUntilSatisfied());
 358
 359   // chrome.mediaGalleriesPrivate.getAllGalleryWatch should return the watched
 360   // gallery identifiers.
 361   ExtensionTestMessageListener get_all_watched_galleries_finished(
 362       kGetAllGalleryWatchResultB, false  /* no reply */);
 363   ExecuteCmdAndCheckReply(host, kGetAllWatchedGalleryIdsCmd,
 364                           kGetAllGalleryWatchOK);
 365   EXPECT_TRUE(get_all_watched_galleries_finished.WaitUntilSatisfied());
 366
 367   // Remove all gallery watchers.
 368   ExecuteCmdAndCheckReply(host, kRemoveAllGalleryWatchCmd,
 369                           kRemoveAllGalleryWatchOK);
 370
 371   // Gallery watchers removed. chrome.mediaGalleriesPrivate.getAllGalleryWatch
 372   // should return an empty list.
 373   ExtensionTestMessageListener final_get_all_check_finished(
 374       kGetAllGalleryWatchResultA, false  /* no reply */);
 375   ExecuteCmdAndCheckReply(host, kGetAllWatchedGalleryIdsCmd,
 376                           kGetAllGalleryWatchOK);
 377   EXPECT_TRUE(final_get_all_check_finished.WaitUntilSatisfied());
 378 }
 379 #endif
 380
 381 #if !defined(OS_WIN) && !defined(OS_CHROMEOS)
 382 // Gallery watch request is not enabled on non-windows platforms.
 383 // Please refer to crbug.com/144491.
 384 IN_PROC_BROWSER_TEST_F(MediaGalleriesPrivateGalleryWatchApiTest,
 385                        SetupGalleryWatch) {
 386   EnsureMediaDirectoriesExists media_directories;
 387   content::RenderViewHost* host = GetBackgroundHostForTestExtension();
 388   ASSERT_TRUE(host);
 389
 390   // Get media file systems.
 391   ExtensionTestMessageListener get_media_systems_finished(
 392       kGetMediaFileSystemsCallbackOK, false  /* no reply */);
 393   ExecuteCmdAndCheckReply(host, kGetMediaFileSystemsCmd,
 394                           kGetMediaFileSystemsOK);
 395   EXPECT_TRUE(get_media_systems_finished.WaitUntilSatisfied());
 396
 397   // Set up a invalid gallery watch.
 398   ExtensionTestMessageListener gallery_watch_request_finished(
 399       kAddGalleryWatchRequestFailed, false  /* no reply */);
 400   // Set up gallery watch.
 401   ExecuteCmdAndCheckReply(host, kSetupWatchOnValidGalleriesCmd,
 402                           kAddGalleryWatchOK);
 403   EXPECT_TRUE(gallery_watch_request_finished.WaitUntilSatisfied());
 404 }
 405
 406 // Gallery watch request is not enabled on non-windows platforms.
 407 // Please refer to crbug.com/144491.
 408 IN_PROC_BROWSER_TEST_F(MediaGalleriesPrivateGalleryWatchApiTest,
 409                        GetAllGalleryWatch) {
 410   EnsureMediaDirectoriesExists media_directories;
 411   content::RenderViewHost* host = GetBackgroundHostForTestExtension();
 412   ASSERT_TRUE(host);
 413
 414   // Get media file systems.
 415   ExtensionTestMessageListener get_media_systems_finished(
 416       kGetMediaFileSystemsCallbackOK, false  /* no reply */);
 417   ExecuteCmdAndCheckReply(host, kGetMediaFileSystemsCmd,
 418                           kGetMediaFileSystemsOK);
 419   EXPECT_TRUE(get_media_systems_finished.WaitUntilSatisfied());
 420
 421   // Set up gallery watch.
 422   ExecuteCmdAndCheckReply(host, kSetupWatchOnValidGalleriesCmd,
 423                           kAddGalleryWatchOK);
 424
 425   // Gallery watchers does not exists.
 426   // chrome.mediaGalleriesPrivate.getAllGalleryWatch should return an empty
 427   // list.
 428   ExtensionTestMessageListener get_all_gallery_watch_finished(
 429       kGetAllGalleryWatchResultA, false  /* no reply */);
 430   ExecuteCmdAndCheckReply(host, kGetAllWatchedGalleryIdsCmd,
 431                           kGetAllGalleryWatchOK);
 432   EXPECT_TRUE(get_all_gallery_watch_finished.WaitUntilSatisfied());
 433 }
 434 #endif