src/chrome/browser/chromeos/file_manager/external_filesystem_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 #include "base/bind.h"
   6 #include "base/files/file_path.h"
   7 #include "base/files/file_util.h"
   8 #include "base/files/scoped_temp_dir.h"
   9 #include "base/path_service.h"
  10 #include "chrome/browser/browser_process.h"
  11 #include "chrome/browser/chromeos/drive/drive_integration_service.h"
  12 #include "chrome/browser/chromeos/file_manager/drive_test_util.h"
  13 #include "chrome/browser/chromeos/file_manager/volume_manager.h"
  14 #include "chrome/browser/chromeos/profiles/profile_helper.h"
  15 #include "chrome/browser/drive/fake_drive_service.h"
  16 #include "chrome/browser/extensions/extension_apitest.h"
  17 #include "chrome/browser/profiles/profile.h"
  18 #include "chrome/browser/profiles/profile_manager.h"
  19 #include "chrome/browser/ui/browser.h"
  20 #include "chrome/common/chrome_constants.h"
  21 #include "chrome/common/chrome_paths.h"
  22 #include "components/user_manager/user_manager.h"
  23 #include "content/public/browser/browser_context.h"
  24 #include "content/public/browser/notification_service.h"
  25 #include "content/public/test/test_utils.h"
  26 #include "extensions/browser/notification_types.h"
  27 #include "extensions/test/result_catcher.h"
  28 #include "google_apis/drive/drive_api_parser.h"
  29 #include "google_apis/drive/test_util.h"
  30 #include "google_apis/drive/time_util.h"
  31 #include "storage/browser/fileapi/external_mount_points.h"
  32
  33 // Tests for access to external file systems (as defined in
  34 // storage/common/fileapi/file_system_types.h) from extensions with
  35 // fileManagerPrivate and fileBrowserHandler extension permissions.
  36 // The tests cover following external file system types:
  37 // - local (kFileSystemTypeLocalNative): a local file system on which files are
  38 //   accessed using native local path.
  39 // - restricted (kFileSystemTypeRestrictedLocalNative): a *read-only* local file
  40 //   system which can only be accessed by extensions that have full access to
  41 //   external file systems (i.e. extensions with fileManagerPrivate permission).
  42 // - drive (kFileSystemTypeDrive): a file system that provides access to Google
  43 //   Drive.
  44 //
  45 // The tests cover following scenarios:
  46 // - Performing file system operations on external file systems from an
  47 //   app with fileManagerPrivate permission (i.e. Files.app).
  48 // - Performing read/write operations from file handler extensions. These
  49 //   extensions need a file browser extension to give them permissions to access
  50 //   files. This also includes file handler extensions in filesystem API.
  51 // - Observing directory changes from a file browser extension (using
  52 //   fileManagerPrivate API).
  53 // - Doing searches on drive file system from file browser extension (using
  54 //   fileManagerPrivate API).
  55
  56 using drive::DriveIntegrationServiceFactory;
  57 using extensions::Extension;
  58
  59 namespace file_manager {
  60 namespace {
  61
  62 // Root dirs for file systems expected by the test extensions.
  63 // NOTE: Root dir for drive file system is set by Chrome's drive implementation,
  64 // but the test will have to make sure the mount point is added before
  65 // starting a test extension using WaitUntilDriveMountPointIsAdded().
  66 const char kLocalMountPointName[] = "local";
  67 const char kRestrictedMountPointName[] = "restricted";
  68
  69 // Default file content for the test files.
  70 const char kTestFileContent[] = "This is some test content.";
  71
  72 // User account email and directory hash for secondary account for multi-profile
  73 // sensitive test cases.
  74 const char kSecondProfileAccount[] = "profile2@test.com";
  75 const char kSecondProfileHash[] = "fileBrowserApiTestProfile2";
  76
  77 // Sets up the initial file system state for native local and restricted native
  78 // local file systems. The hierarchy is the same as for the drive file system.
  79 // The directory is created at unique_temp_dir/|mount_point_name| path.
  80 bool InitializeLocalFileSystem(std::string mount_point_name,
  81                                base::ScopedTempDir* tmp_dir,
  82                                base::FilePath* mount_point_dir) {
  83   if (!tmp_dir->CreateUniqueTempDir())
  84     return false;
  85
  86   *mount_point_dir = tmp_dir->path().AppendASCII(mount_point_name);
  87   // Create the mount point.
  88   if (!base::CreateDirectory(*mount_point_dir))
  89     return false;
  90
  91   base::FilePath test_dir = mount_point_dir->AppendASCII("test_dir");
  92   if (!base::CreateDirectory(test_dir))
  93     return false;
  94
  95   base::FilePath test_subdir = test_dir.AppendASCII("empty_test_dir");
  96   if (!base::CreateDirectory(test_subdir))
  97     return false;
  98
  99   test_subdir = test_dir.AppendASCII("subdir");
 100   if (!base::CreateDirectory(test_subdir))
 101     return false;
 102
 103   base::FilePath test_file = test_dir.AppendASCII("test_file.xul");
 104   if (!google_apis::test_util::WriteStringToFile(test_file, kTestFileContent))
 105     return false;
 106
 107   test_file = test_dir.AppendASCII("test_file.xul.foo");
 108   if (!google_apis::test_util::WriteStringToFile(test_file, kTestFileContent))
 109     return false;
 110
 111   test_file = test_dir.AppendASCII("test_file.tiff");
 112   if (!google_apis::test_util::WriteStringToFile(test_file, kTestFileContent))
 113     return false;
 114
 115   test_file = test_dir.AppendASCII("test_file.tiff.foo");
 116   if (!google_apis::test_util::WriteStringToFile(test_file, kTestFileContent))
 117     return false;
 118
 119   test_file = test_dir.AppendASCII("empty_test_file.foo");
 120   if (!google_apis::test_util::WriteStringToFile(test_file, ""))
 121     return false;
 122
 123   return true;
 124 }
 125
 126 scoped_ptr<google_apis::FileResource> UpdateDriveEntryTime(
 127     drive::FakeDriveService* fake_drive_service,
 128     const std::string& resource_id,
 129     const std::string& last_modified,
 130     const std::string& last_viewed_by_me) {
 131   base::Time last_modified_time, last_viewed_by_me_time;
 132   if (!google_apis::util::GetTimeFromString(last_modified,
 133                                             &last_modified_time) ||
 134       !google_apis::util::GetTimeFromString(last_viewed_by_me,
 135                                             &last_viewed_by_me_time))
 136     return scoped_ptr<google_apis::FileResource>();
 137
 138   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
 139   scoped_ptr<google_apis::FileResource> entry;
 140   fake_drive_service->UpdateResource(
 141       resource_id,
 142       std::string(),  // parent_resource_id
 143       std::string(),  // title
 144       last_modified_time,
 145       last_viewed_by_me_time,
 146       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
 147   base::RunLoop().RunUntilIdle();
 148   if (error != google_apis::HTTP_SUCCESS)
 149     return scoped_ptr<google_apis::FileResource>();
 150
 151   return entry.Pass();
 152 }
 153
 154 scoped_ptr<google_apis::FileResource> AddFileToDriveService(
 155     drive::FakeDriveService* fake_drive_service,
 156     const std::string& mime_type,
 157     const std::string& content,
 158     const std::string& parent_resource_id,
 159     const std::string& title,
 160     const std::string& last_modified,
 161     const std::string& last_viewed_by_me) {
 162   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
 163   scoped_ptr<google_apis::FileResource> entry;
 164   fake_drive_service->AddNewFile(
 165       mime_type,
 166       content,
 167       parent_resource_id,
 168       title,
 169       false,  // shared_with_me
 170       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
 171   base::RunLoop().RunUntilIdle();
 172   if (error != google_apis::HTTP_CREATED)
 173     return scoped_ptr<google_apis::FileResource>();
 174
 175   return UpdateDriveEntryTime(fake_drive_service, entry->file_id(),
 176                               last_modified, last_viewed_by_me);
 177 }
 178
 179 scoped_ptr<google_apis::FileResource> AddDirectoryToDriveService(
 180     drive::FakeDriveService* fake_drive_service,
 181     const std::string& parent_resource_id,
 182     const std::string& title,
 183     const std::string& last_modified,
 184     const std::string& last_viewed_by_me) {
 185   google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
 186   scoped_ptr<google_apis::FileResource> entry;
 187   fake_drive_service->AddNewDirectory(
 188       parent_resource_id,
 189       title,
 190       drive::DriveServiceInterface::AddNewDirectoryOptions(),
 191       google_apis::test_util::CreateCopyResultCallback(&error, &entry));
 192   base::RunLoop().RunUntilIdle();
 193   if (error != google_apis::HTTP_CREATED)
 194     return scoped_ptr<google_apis::FileResource>();
 195
 196   return UpdateDriveEntryTime(fake_drive_service, entry->file_id(),
 197                               last_modified, last_viewed_by_me);
 198 }
 199
 200 // Sets up the drive service state.
 201 // The hierarchy is the same as for the local file system.
 202 bool InitializeDriveService(
 203     drive::FakeDriveService* fake_drive_service,
 204     std::map<std::string, std::string>* out_resource_ids) {
 205   scoped_ptr<google_apis::FileResource> entry;
 206
 207   entry = AddDirectoryToDriveService(fake_drive_service,
 208                                      fake_drive_service->GetRootResourceId(),
 209                                      "test_dir",
 210                                      "2012-01-02T00:00:00.000Z",
 211                                      "2012-01-02T00:00:01.000Z");
 212   if (!entry)
 213     return false;
 214   (*out_resource_ids)[entry->title()] = entry->file_id();
 215
 216   entry = AddDirectoryToDriveService(fake_drive_service,
 217                                      (*out_resource_ids)["test_dir"],
 218                                      "empty_test_dir",
 219                                      "2011-11-02T04:00:00.000Z",
 220                                      "2011-11-02T04:00:00.000Z");
 221   if (!entry)
 222     return false;
 223   (*out_resource_ids)[entry->title()] = entry->file_id();
 224
 225   entry = AddDirectoryToDriveService(fake_drive_service,
 226                                      (*out_resource_ids)["test_dir"],
 227                                      "subdir",
 228                                      "2011-04-01T18:34:08.234Z",
 229                                      "2012-01-02T00:00:01.000Z");
 230   if (!entry)
 231     return false;
 232   (*out_resource_ids)[entry->title()] = entry->file_id();
 233
 234   entry = AddFileToDriveService(fake_drive_service,
 235                                 "application/vnd.mozilla.xul+xml",
 236                                 kTestFileContent,
 237                                 (*out_resource_ids)["test_dir"],
 238                                 "test_file.xul",
 239                                 "2011-12-14T00:40:47.330Z",
 240                                 "2012-01-02T00:00:00.000Z");
 241   if (!entry)
 242     return false;
 243   (*out_resource_ids)[entry->title()] = entry->file_id();
 244
 245   entry = AddFileToDriveService(fake_drive_service,
 246                                 "test/ro",
 247                                 kTestFileContent,
 248                                 (*out_resource_ids)["test_dir"],
 249                                 "test_file.xul.foo",
 250                                 "2012-01-01T10:00:30.000Z",
 251                                 "2012-01-01T00:00:00.000Z");
 252   if (!entry)
 253     return false;
 254   (*out_resource_ids)[entry->title()] = entry->file_id();
 255
 256   entry = AddFileToDriveService(fake_drive_service,
 257                                 "image/tiff",
 258                                 kTestFileContent,
 259                                 (*out_resource_ids)["test_dir"],
 260                                 "test_file.tiff",
 261                                 "2011-04-03T11:11:10.000Z",
 262                                 "2012-01-02T00:00:00.000Z");
 263   if (!entry)
 264     return false;
 265   (*out_resource_ids)[entry->title()] = entry->file_id();
 266
 267   entry = AddFileToDriveService(fake_drive_service,
 268                                 "test/rw",
 269                                 kTestFileContent,
 270                                 (*out_resource_ids)["test_dir"],
 271                                 "test_file.tiff.foo",
 272                                 "2011-12-14T00:40:47.330Z",
 273                                 "2010-01-02T00:00:00.000Z");
 274   if (!entry)
 275     return false;
 276   (*out_resource_ids)[entry->title()] = entry->file_id();
 277
 278   entry = AddFileToDriveService(fake_drive_service,
 279                                 "test/rw",
 280                                 "",
 281                                 (*out_resource_ids)["test_dir"],
 282                                 "empty_test_file.foo",
 283                                 "2011-12-14T00:40:47.330Z",
 284                                 "2011-12-14T00:40:47.330Z");
 285   if (!entry)
 286     return false;
 287   (*out_resource_ids)[entry->title()] = entry->file_id();
 288
 289   return true;
 290 }
 291
 292 // Helper class to wait for a background page to load or close again.
 293 class BackgroundObserver {
 294  public:
 295   BackgroundObserver()
 296       : page_created_(extensions::NOTIFICATION_EXTENSION_BACKGROUND_PAGE_READY,
 297                       content::NotificationService::AllSources()),
 298         page_closed_(extensions::NOTIFICATION_EXTENSION_HOST_DESTROYED,
 299                      content::NotificationService::AllSources()) {}
 300
 301   void WaitUntilLoaded() {
 302     page_created_.Wait();
 303   }
 304
 305   void WaitUntilClosed() {
 306     page_closed_.Wait();
 307   }
 308
 309  private:
 310   content::WindowedNotificationObserver page_created_;
 311   content::WindowedNotificationObserver page_closed_;
 312 };
 313
 314 // Base class for FileSystemExtensionApi tests.
 315 class FileSystemExtensionApiTestBase : public ExtensionApiTest {
 316  public:
 317   enum Flags {
 318     FLAGS_NONE = 0,
 319     FLAGS_USE_FILE_HANDLER = 1 << 1,
 320     FLAGS_LAZY_FILE_HANDLER = 1 << 2
 321   };
 322
 323   FileSystemExtensionApiTestBase() {}
 324   virtual ~FileSystemExtensionApiTestBase() {}
 325
 326   virtual void SetUp() OVERRIDE {
 327     InitTestFileSystem();
 328     ExtensionApiTest::SetUp();
 329   }
 330
 331   virtual void SetUpOnMainThread() OVERRIDE {
 332     AddTestMountPoint();
 333     ExtensionApiTest::SetUpOnMainThread();
 334   }
 335
 336   // Runs a file system extension API test.
 337   // It loads test component extension at |filebrowser_path| with manifest
 338   // at |filebrowser_manifest|. The |filebrowser_manifest| should be a path
 339   // relative to |filebrowser_path|. The method waits until the test extension
 340   // sends test succeed or fail message. It returns true if the test succeeds.
 341   // If |FLAGS_USE_FILE_HANDLER| flag is set, the file handler extension at path
 342   // |filehandler_path| will be loaded before the file browser extension.
 343   // If the flag FLAGS_LAZY_FILE_HANDLER is set, the file handler extension must
 344   // not have persistent background page. The test will wait until the file
 345   // handler's background page is closed after initial load before the file
 346   // browser extension is loaded.
 347   // If |RunFileSystemExtensionApiTest| fails, |message_| will contain a failure
 348   // message.
 349   bool RunFileSystemExtensionApiTest(
 350       const std::string& filebrowser_path,
 351       const base::FilePath::CharType* filebrowser_manifest,
 352       const std::string& filehandler_path,
 353       int flags) {
 354     if (flags & FLAGS_USE_FILE_HANDLER) {
 355       if (filehandler_path.empty()) {
 356         message_ = "Missing file handler path.";
 357         return false;
 358       }
 359
 360       BackgroundObserver page_complete;
 361       const Extension* file_handler =
 362           LoadExtension(test_data_dir_.AppendASCII(filehandler_path));
 363       if (!file_handler)
 364         return false;
 365
 366       if (flags & FLAGS_LAZY_FILE_HANDLER) {
 367         page_complete.WaitUntilClosed();
 368       } else {
 369         page_complete.WaitUntilLoaded();
 370       }
 371     }
 372
 373     extensions::ResultCatcher catcher;
 374
 375     const Extension* file_browser = LoadExtensionAsComponentWithManifest(
 376         test_data_dir_.AppendASCII(filebrowser_path),
 377         filebrowser_manifest);
 378     if (!file_browser)
 379       return false;
 380
 381     if (!catcher.GetNextResult()) {
 382       message_ = catcher.message();
 383       return false;
 384     }
 385
 386     return true;
 387   }
 388
 389  protected:
 390   // Sets up initial test file system hierarchy.
 391   virtual void InitTestFileSystem() = 0;
 392   // Registers mount point used in the test.
 393   virtual void AddTestMountPoint() = 0;
 394 };
 395
 396 // Tests for a native local file system.
 397 class LocalFileSystemExtensionApiTest : public FileSystemExtensionApiTestBase {
 398  public:
 399   LocalFileSystemExtensionApiTest() {}
 400   virtual ~LocalFileSystemExtensionApiTest() {}
 401
 402   // FileSystemExtensionApiTestBase OVERRIDE.
 403   virtual void InitTestFileSystem() OVERRIDE {
 404     ASSERT_TRUE(InitializeLocalFileSystem(
 405         kLocalMountPointName, &tmp_dir_, &mount_point_dir_))
 406         << "Failed to initialize file system.";
 407   }
 408
 409   // FileSystemExtensionApiTestBase OVERRIDE.
 410   virtual void AddTestMountPoint() OVERRIDE {
 411     EXPECT_TRUE(content::BrowserContext::GetMountPoints(browser()->profile())
 412                     ->RegisterFileSystem(kLocalMountPointName,
 413                                          storage::kFileSystemTypeNativeLocal,
 414                                          storage::FileSystemMountOption(),
 415                                          mount_point_dir_));
 416     VolumeManager::Get(browser()->profile())->AddVolumeInfoForTesting(
 417         mount_point_dir_, VOLUME_TYPE_TESTING, chromeos::DEVICE_TYPE_UNKNOWN);
 418   }
 419
 420  private:
 421   base::ScopedTempDir tmp_dir_;
 422   base::FilePath mount_point_dir_;
 423 };
 424
 425 // Tests for restricted native local file systems.
 426 class RestrictedFileSystemExtensionApiTest
 427     : public FileSystemExtensionApiTestBase {
 428  public:
 429   RestrictedFileSystemExtensionApiTest() {}
 430   virtual ~RestrictedFileSystemExtensionApiTest() {}
 431
 432   // FileSystemExtensionApiTestBase OVERRIDE.
 433   virtual void InitTestFileSystem() OVERRIDE {
 434     ASSERT_TRUE(InitializeLocalFileSystem(
 435         kRestrictedMountPointName, &tmp_dir_, &mount_point_dir_))
 436         << "Failed to initialize file system.";
 437   }
 438
 439   // FileSystemExtensionApiTestBase OVERRIDE.
 440   virtual void AddTestMountPoint() OVERRIDE {
 441     EXPECT_TRUE(
 442         content::BrowserContext::GetMountPoints(browser()->profile())
 443             ->RegisterFileSystem(kRestrictedMountPointName,
 444                                  storage::kFileSystemTypeRestrictedNativeLocal,
 445                                  storage::FileSystemMountOption(),
 446                                  mount_point_dir_));
 447     VolumeManager::Get(browser()->profile())->AddVolumeInfoForTesting(
 448         mount_point_dir_, VOLUME_TYPE_TESTING, chromeos::DEVICE_TYPE_UNKNOWN);
 449   }
 450
 451  private:
 452   base::ScopedTempDir tmp_dir_;
 453   base::FilePath mount_point_dir_;
 454 };
 455
 456 // Tests for a drive file system.
 457 class DriveFileSystemExtensionApiTest : public FileSystemExtensionApiTestBase {
 458  public:
 459   DriveFileSystemExtensionApiTest() : fake_drive_service_(NULL) {}
 460   virtual ~DriveFileSystemExtensionApiTest() {}
 461
 462   // FileSystemExtensionApiTestBase OVERRIDE.
 463   virtual void InitTestFileSystem() OVERRIDE {
 464     // Set up cache root to be used by DriveIntegrationService. This has to be
 465     // done before the browser is created because the service instance is
 466     // initialized by EventRouter.
 467     ASSERT_TRUE(test_cache_root_.CreateUniqueTempDir());
 468
 469     // This callback will get called during Profile creation.
 470     create_drive_integration_service_ = base::Bind(
 471         &DriveFileSystemExtensionApiTest::CreateDriveIntegrationService,
 472         base::Unretained(this));
 473     service_factory_for_test_.reset(
 474         new DriveIntegrationServiceFactory::ScopedFactoryForTest(
 475             &create_drive_integration_service_));
 476   }
 477
 478   // FileSystemExtensionApiTestBase OVERRIDE.
 479   virtual void AddTestMountPoint() OVERRIDE {
 480     test_util::WaitUntilDriveMountPointIsAdded(browser()->profile());
 481   }
 482
 483  protected:
 484   // DriveIntegrationService factory function for this test.
 485   drive::DriveIntegrationService* CreateDriveIntegrationService(
 486       Profile* profile) {
 487     fake_drive_service_ = new drive::FakeDriveService;
 488     fake_drive_service_->LoadAppListForDriveApi("drive/applist.json");
 489
 490     std::map<std::string, std::string> resource_ids;
 491     EXPECT_TRUE(InitializeDriveService(fake_drive_service_, &resource_ids));
 492
 493     return new drive::DriveIntegrationService(
 494         profile, NULL,
 495         fake_drive_service_, "drive", test_cache_root_.path(), NULL);
 496   }
 497
 498   base::ScopedTempDir test_cache_root_;
 499   drive::FakeDriveService* fake_drive_service_;
 500   DriveIntegrationServiceFactory::FactoryCallback
 501       create_drive_integration_service_;
 502   scoped_ptr<DriveIntegrationServiceFactory::ScopedFactoryForTest>
 503       service_factory_for_test_;
 504 };
 505
 506 // Tests for Drive file systems in multi-profile setting.
 507 class MultiProfileDriveFileSystemExtensionApiTest :
 508     public FileSystemExtensionApiTestBase {
 509  public:
 510   MultiProfileDriveFileSystemExtensionApiTest() : second_profile(NULL) {}
 511
 512   virtual void SetUpOnMainThread() OVERRIDE {
 513     base::FilePath user_data_directory;
 514     PathService::Get(chrome::DIR_USER_DATA, &user_data_directory);
 515     user_manager::UserManager::Get()->UserLoggedIn(
 516         kSecondProfileAccount, kSecondProfileHash, false);
 517     // Set up the secondary profile.
 518     base::FilePath profile_dir =
 519         user_data_directory.Append(
 520             chromeos::ProfileHelper::GetUserProfileDir(
 521                 kSecondProfileHash).BaseName());
 522     second_profile =
 523         g_browser_process->profile_manager()->GetProfile(profile_dir);
 524
 525     FileSystemExtensionApiTestBase::SetUpOnMainThread();
 526   }
 527
 528   virtual void InitTestFileSystem() OVERRIDE {
 529     // This callback will get called during Profile creation.
 530     create_drive_integration_service_ = base::Bind(
 531         &MultiProfileDriveFileSystemExtensionApiTest::
 532             CreateDriveIntegrationService,
 533         base::Unretained(this));
 534     service_factory_for_test_.reset(
 535         new DriveIntegrationServiceFactory::ScopedFactoryForTest(
 536             &create_drive_integration_service_));
 537   }
 538
 539   virtual void AddTestMountPoint() OVERRIDE {
 540     test_util::WaitUntilDriveMountPointIsAdded(browser()->profile());
 541     test_util::WaitUntilDriveMountPointIsAdded(second_profile);
 542   }
 543
 544  protected:
 545   // DriveIntegrationService factory function for this test.
 546   drive::DriveIntegrationService* CreateDriveIntegrationService(
 547       Profile* profile) {
 548     base::FilePath cache_dir;
 549     base::CreateNewTempDirectory(base::FilePath::StringType(), &cache_dir);
 550
 551     drive::FakeDriveService* const fake_drive_service =
 552         new drive::FakeDriveService;
 553     fake_drive_service->LoadAppListForDriveApi("drive/applist.json");
 554     EXPECT_TRUE(InitializeDriveService(fake_drive_service, &resource_ids_));
 555
 556     return new drive::DriveIntegrationService(
 557         profile, NULL, fake_drive_service, std::string(), cache_dir, NULL);
 558   }
 559
 560   bool AddTestHostedDocuments() {
 561     const char kResourceId[] = "unique-id-for-multiprofile-copy-test";
 562     drive::FakeDriveService* const main_service =
 563         static_cast<drive::FakeDriveService*>(
 564             drive::util::GetDriveServiceByProfile(browser()->profile()));
 565     drive::FakeDriveService* const sub_service =
 566         static_cast<drive::FakeDriveService*>(
 567             drive::util::GetDriveServiceByProfile(second_profile));
 568
 569     google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR;
 570     scoped_ptr<google_apis::FileResource> entry;
 571
 572     // Place a hosted document under root/test_dir of the sub profile.
 573     sub_service->AddNewFileWithResourceId(
 574         kResourceId,
 575         "application/vnd.google-apps.document", "",
 576         resource_ids_["test_dir"], "hosted_doc", true,
 577         google_apis::test_util::CreateCopyResultCallback(&error, &entry));
 578     content::RunAllBlockingPoolTasksUntilIdle();
 579     if (error != google_apis::HTTP_CREATED)
 580       return false;
 581
 582     // Place the hosted document with no parent in the main profile, for
 583     // simulating the situation that the document is shared to the main profile.
 584     error = google_apis::GDATA_OTHER_ERROR;
 585     main_service->AddNewFileWithResourceId(
 586         kResourceId,
 587         "application/vnd.google-apps.document", "", "", "hosted_doc", true,
 588         google_apis::test_util::CreateCopyResultCallback(&error, &entry));
 589     content::RunAllBlockingPoolTasksUntilIdle();
 590     return (error == google_apis::HTTP_CREATED);
 591   }
 592
 593   DriveIntegrationServiceFactory::FactoryCallback
 594       create_drive_integration_service_;
 595   scoped_ptr<DriveIntegrationServiceFactory::ScopedFactoryForTest>
 596       service_factory_for_test_;
 597   Profile* second_profile;
 598   std::map<std::string, std::string> resource_ids_;
 599 };
 600
 601 class LocalAndDriveFileSystemExtensionApiTest
 602     : public FileSystemExtensionApiTestBase {
 603  public:
 604   LocalAndDriveFileSystemExtensionApiTest() {}
 605   virtual ~LocalAndDriveFileSystemExtensionApiTest() {}
 606
 607   // FileSystemExtensionApiTestBase OVERRIDE.
 608   virtual void InitTestFileSystem() OVERRIDE {
 609     ASSERT_TRUE(InitializeLocalFileSystem(
 610         kLocalMountPointName, &local_tmp_dir_, &local_mount_point_dir_))
 611         << "Failed to initialize file system.";
 612
 613     // Set up cache root to be used by DriveIntegrationService. This has to be
 614     // done before the browser is created because the service instance is
 615     // initialized by EventRouter.
 616     ASSERT_TRUE(test_cache_root_.CreateUniqueTempDir());
 617
 618     // This callback will get called during Profile creation.
 619     create_drive_integration_service_ = base::Bind(
 620         &LocalAndDriveFileSystemExtensionApiTest::CreateDriveIntegrationService,
 621         base::Unretained(this));
 622     service_factory_for_test_.reset(
 623         new DriveIntegrationServiceFactory::ScopedFactoryForTest(
 624             &create_drive_integration_service_));
 625   }
 626
 627   // FileSystemExtensionApiTestBase OVERRIDE.
 628   virtual void AddTestMountPoint() OVERRIDE {
 629     EXPECT_TRUE(content::BrowserContext::GetMountPoints(browser()->profile())
 630                     ->RegisterFileSystem(kLocalMountPointName,
 631                                          storage::kFileSystemTypeNativeLocal,
 632                                          storage::FileSystemMountOption(),
 633                                          local_mount_point_dir_));
 634     VolumeManager::Get(browser()->profile())
 635         ->AddVolumeInfoForTesting(local_mount_point_dir_,
 636                                   VOLUME_TYPE_TESTING,
 637                                   chromeos::DEVICE_TYPE_UNKNOWN);
 638     test_util::WaitUntilDriveMountPointIsAdded(browser()->profile());
 639   }
 640
 641  protected:
 642   // DriveIntegrationService factory function for this test.
 643   drive::DriveIntegrationService* CreateDriveIntegrationService(
 644       Profile* profile) {
 645     fake_drive_service_ = new drive::FakeDriveService;
 646     fake_drive_service_->LoadAppListForDriveApi("drive/applist.json");
 647
 648     std::map<std::string, std::string> resource_ids;
 649     EXPECT_TRUE(InitializeDriveService(fake_drive_service_, &resource_ids));
 650
 651     return new drive::DriveIntegrationService(profile,
 652                                               NULL,
 653                                               fake_drive_service_,
 654                                               "drive",
 655                                               test_cache_root_.path(),
 656                                               NULL);
 657   }
 658
 659  private:
 660   // For local volume.
 661   base::ScopedTempDir local_tmp_dir_;
 662   base::FilePath local_mount_point_dir_;
 663
 664   // For drive volume.
 665   base::ScopedTempDir test_cache_root_;
 666   drive::FakeDriveService* fake_drive_service_;
 667   DriveIntegrationServiceFactory::FactoryCallback
 668       create_drive_integration_service_;
 669   scoped_ptr<DriveIntegrationServiceFactory::ScopedFactoryForTest>
 670       service_factory_for_test_;
 671 };
 672
 673 //
 674 // LocalFileSystemExtensionApiTests.
 675 //
 676
 677 IN_PROC_BROWSER_TEST_F(LocalFileSystemExtensionApiTest, FileSystemOperations) {
 678   EXPECT_TRUE(RunFileSystemExtensionApiTest(
 679       "file_browser/filesystem_operations_test",
 680       FILE_PATH_LITERAL("manifest.json"),
 681       "",
 682       FLAGS_NONE)) << message_;
 683 }
 684
 685 IN_PROC_BROWSER_TEST_F(LocalFileSystemExtensionApiTest, FileWatch) {
 686   EXPECT_TRUE(RunFileSystemExtensionApiTest(
 687       "file_browser/file_watcher_test",
 688       FILE_PATH_LITERAL("manifest.json"),
 689       "",
 690       FLAGS_NONE)) << message_;
 691 }
 692
 693 IN_PROC_BROWSER_TEST_F(LocalFileSystemExtensionApiTest, FileBrowserHandlers) {
 694   EXPECT_TRUE(RunFileSystemExtensionApiTest(
 695       "file_browser/handler_test_runner",
 696       FILE_PATH_LITERAL("manifest.json"),
 697       "file_browser/file_browser_handler",
 698       FLAGS_USE_FILE_HANDLER)) << message_;
 699 }
 700
 701 IN_PROC_BROWSER_TEST_F(LocalFileSystemExtensionApiTest,
 702                        FileBrowserHandlersLazy) {
 703   EXPECT_TRUE(RunFileSystemExtensionApiTest(
 704       "file_browser/handler_test_runner",
 705       FILE_PATH_LITERAL("manifest.json"),
 706       "file_browser/file_browser_handler_lazy",
 707       FLAGS_USE_FILE_HANDLER | FLAGS_LAZY_FILE_HANDLER)) << message_;
 708 }
 709
 710 IN_PROC_BROWSER_TEST_F(LocalFileSystemExtensionApiTest, AppFileHandler) {
 711   EXPECT_TRUE(RunFileSystemExtensionApiTest(
 712       "file_browser/handler_test_runner",
 713       FILE_PATH_LITERAL("manifest.json"),
 714       "file_browser/app_file_handler",
 715       FLAGS_USE_FILE_HANDLER)) << message_;
 716 }
 717
 718 //
 719 // RestrictedFileSystemExtensionApiTests.
 720 //
 721 IN_PROC_BROWSER_TEST_F(RestrictedFileSystemExtensionApiTest,
 722                        FileSystemOperations) {
 723   EXPECT_TRUE(RunFileSystemExtensionApiTest(
 724       "file_browser/filesystem_operations_test",
 725       FILE_PATH_LITERAL("manifest.json"),
 726       "",
 727       FLAGS_NONE)) << message_;
 728 }
 729
 730 //
 731 // DriveFileSystemExtensionApiTests.
 732 //
 733 IN_PROC_BROWSER_TEST_F(DriveFileSystemExtensionApiTest, FileSystemOperations) {
 734   EXPECT_TRUE(RunFileSystemExtensionApiTest(
 735       "file_browser/filesystem_operations_test",
 736       FILE_PATH_LITERAL("manifest.json"),
 737       "",
 738       FLAGS_NONE)) << message_;
 739 }
 740
 741 IN_PROC_BROWSER_TEST_F(DriveFileSystemExtensionApiTest, FileWatch) {
 742   EXPECT_TRUE(RunFileSystemExtensionApiTest(
 743       "file_browser/file_watcher_test",
 744       FILE_PATH_LITERAL("manifest.json"),
 745       "",
 746       FLAGS_NONE)) << message_;
 747 }
 748
 749 IN_PROC_BROWSER_TEST_F(DriveFileSystemExtensionApiTest, FileBrowserHandlers) {
 750   EXPECT_TRUE(RunFileSystemExtensionApiTest(
 751       "file_browser/handler_test_runner",
 752       FILE_PATH_LITERAL("manifest.json"),
 753       "file_browser/file_browser_handler",
 754       FLAGS_USE_FILE_HANDLER)) << message_;
 755 }
 756
 757 IN_PROC_BROWSER_TEST_F(DriveFileSystemExtensionApiTest, Search) {
 758   // Configure the drive service to return only one search result at a time
 759   // to simulate paginated searches.
 760   fake_drive_service_->set_default_max_results(1);
 761   EXPECT_TRUE(RunFileSystemExtensionApiTest(
 762       "file_browser/drive_search_test",
 763       FILE_PATH_LITERAL("manifest.json"),
 764       "",
 765       FLAGS_NONE)) << message_;
 766 }
 767
 768 IN_PROC_BROWSER_TEST_F(DriveFileSystemExtensionApiTest, AppFileHandler) {
 769   EXPECT_TRUE(RunFileSystemExtensionApiTest(
 770       "file_browser/handler_test_runner",
 771       FILE_PATH_LITERAL("manifest.json"),
 772       "file_browser/app_file_handler",
 773       FLAGS_USE_FILE_HANDLER)) << message_;
 774 }
 775
 776 IN_PROC_BROWSER_TEST_F(DriveFileSystemExtensionApiTest,
 777                        FileSystemFileOriginURL) {
 778   EXPECT_TRUE(RunFileSystemExtensionApiTest(
 779       "file_browser/filesystem_file_origin_url",
 780       FILE_PATH_LITERAL("manifest.json"),
 781       "",
 782       FLAGS_NONE)) << message_;
 783 }
 784
 785 IN_PROC_BROWSER_TEST_F(MultiProfileDriveFileSystemExtensionApiTest,
 786                        CrossProfileCopy) {
 787   ASSERT_TRUE(AddTestHostedDocuments());
 788   EXPECT_TRUE(RunFileSystemExtensionApiTest(
 789       "file_browser/multi_profile_copy",
 790       FILE_PATH_LITERAL("manifest.json"),
 791       "",
 792       FLAGS_NONE)) << message_;
 793 }
 794
 795 //
 796 // LocalAndDriveFileSystemExtensionApiTests.
 797 //
 798 IN_PROC_BROWSER_TEST_F(LocalAndDriveFileSystemExtensionApiTest,
 799                        AppFileHandlerMulti) {
 800   EXPECT_TRUE(
 801       RunFileSystemExtensionApiTest("file_browser/app_file_handler_multi",
 802                                     FILE_PATH_LITERAL("manifest.json"),
 803                                     "",
 804                                     FLAGS_NONE))
 805       << message_;
 806 }
 807 }  // namespace
 808 }  // namespace file_manager