file_manager_browsertest.cc revision 03b57e008b61dfcb1fbad3aea950ae0e001748b0
1// Copyright (c) 2013 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// Browser test for basic Chrome OS file manager functionality: 6// - The file list is updated when a file is added externally to the Downloads 7// folder. 8// - Selecting a file and copy-pasting it with the keyboard copies the file. 9// - Selecting a file and pressing delete deletes it. 10 11#include <deque> 12#include <string> 13 14#include "apps/app_window.h" 15#include "apps/app_window_registry.h" 16#include "base/bind.h" 17#include "base/file_util.h" 18#include "base/files/file_path.h" 19#include "base/json/json_reader.h" 20#include "base/json/json_value_converter.h" 21#include "base/json/json_writer.h" 22#include "base/prefs/pref_service.h" 23#include "base/strings/string_piece.h" 24#include "base/strings/utf_string_conversions.h" 25#include "base/time/time.h" 26#include "chrome/browser/chromeos/drive/drive_integration_service.h" 27#include "chrome/browser/chromeos/drive/file_system_interface.h" 28#include "chrome/browser/chromeos/file_manager/app_id.h" 29#include "chrome/browser/chromeos/file_manager/drive_test_util.h" 30#include "chrome/browser/chromeos/file_manager/path_util.h" 31#include "chrome/browser/chromeos/file_manager/volume_manager.h" 32#include "chrome/browser/chromeos/profiles/profile_helper.h" 33#include "chrome/browser/drive/fake_drive_service.h" 34#include "chrome/browser/extensions/component_loader.h" 35#include "chrome/browser/extensions/extension_apitest.h" 36#include "chrome/browser/extensions/extension_test_message_listener.h" 37#include "chrome/browser/profiles/profile.h" 38#include "chrome/browser/ui/ash/multi_user/multi_user_util.h" 39#include "chrome/browser/ui/ash/multi_user/multi_user_window_manager.h" 40#include "chrome/common/chrome_switches.h" 41#include "chrome/common/pref_names.h" 42#include "chromeos/chromeos_switches.h" 43#include "components/user_manager/user_manager.h" 44#include "content/public/browser/notification_service.h" 45#include "content/public/test/test_utils.h" 46#include "extensions/browser/api/test/test_api.h" 47#include "extensions/browser/notification_types.h" 48#include "extensions/common/extension.h" 49#include "google_apis/drive/drive_api_parser.h" 50#include "google_apis/drive/test_util.h" 51#include "net/test/embedded_test_server/embedded_test_server.h" 52#include "webkit/browser/fileapi/external_mount_points.h" 53 54using drive::DriveIntegrationServiceFactory; 55 56namespace file_manager { 57namespace { 58 59enum EntryType { 60 FILE, 61 DIRECTORY, 62}; 63 64enum TargetVolume { LOCAL_VOLUME, DRIVE_VOLUME, USB_VOLUME, }; 65 66enum SharedOption { 67 NONE, 68 SHARED, 69}; 70 71enum GuestMode { 72 NOT_IN_GUEST_MODE, 73 IN_GUEST_MODE, 74 IN_INCOGNITO 75}; 76 77// This global operator is used from Google Test to format error messages. 78std::ostream& operator<<(std::ostream& os, const GuestMode& guest_mode) { 79 return os << (guest_mode == IN_GUEST_MODE ? 80 "IN_GUEST_MODE" : "NOT_IN_GUEST_MODE"); 81} 82 83// Maps the given string to EntryType. Returns true on success. 84bool MapStringToEntryType(const base::StringPiece& value, EntryType* output) { 85 if (value == "file") 86 *output = FILE; 87 else if (value == "directory") 88 *output = DIRECTORY; 89 else 90 return false; 91 return true; 92} 93 94// Maps the given string to SharedOption. Returns true on success. 95bool MapStringToSharedOption(const base::StringPiece& value, 96 SharedOption* output) { 97 if (value == "shared") 98 *output = SHARED; 99 else if (value == "none") 100 *output = NONE; 101 else 102 return false; 103 return true; 104} 105 106// Maps the given string to TargetVolume. Returns true on success. 107bool MapStringToTargetVolume(const base::StringPiece& value, 108 TargetVolume* output) { 109 if (value == "drive") 110 *output = DRIVE_VOLUME; 111 else if (value == "local") 112 *output = LOCAL_VOLUME; 113 else if (value == "usb") 114 *output = USB_VOLUME; 115 else 116 return false; 117 return true; 118} 119 120// Maps the given string to base::Time. Returns true on success. 121bool MapStringToTime(const base::StringPiece& value, base::Time* time) { 122 return base::Time::FromString(value.as_string().c_str(), time); 123} 124 125// Test data of file or directory. 126struct TestEntryInfo { 127 TestEntryInfo() : type(FILE), shared_option(NONE) {} 128 129 TestEntryInfo(EntryType type, 130 const std::string& source_file_name, 131 const std::string& target_path, 132 const std::string& mime_type, 133 SharedOption shared_option, 134 const base::Time& last_modified_time) : 135 type(type), 136 source_file_name(source_file_name), 137 target_path(target_path), 138 mime_type(mime_type), 139 shared_option(shared_option), 140 last_modified_time(last_modified_time) { 141 } 142 143 EntryType type; 144 std::string source_file_name; // Source file name to be used as a prototype. 145 std::string target_path; // Target file or directory path. 146 std::string mime_type; 147 SharedOption shared_option; 148 base::Time last_modified_time; 149 150 // Registers the member information to the given converter. 151 static void RegisterJSONConverter( 152 base::JSONValueConverter<TestEntryInfo>* converter); 153}; 154 155// static 156void TestEntryInfo::RegisterJSONConverter( 157 base::JSONValueConverter<TestEntryInfo>* converter) { 158 converter->RegisterCustomField("type", 159 &TestEntryInfo::type, 160 &MapStringToEntryType); 161 converter->RegisterStringField("sourceFileName", 162 &TestEntryInfo::source_file_name); 163 converter->RegisterStringField("targetPath", &TestEntryInfo::target_path); 164 converter->RegisterStringField("mimeType", &TestEntryInfo::mime_type); 165 converter->RegisterCustomField("sharedOption", 166 &TestEntryInfo::shared_option, 167 &MapStringToSharedOption); 168 converter->RegisterCustomField("lastModifiedTime", 169 &TestEntryInfo::last_modified_time, 170 &MapStringToTime); 171} 172 173// Message from JavaScript to add entries. 174struct AddEntriesMessage { 175 // Target volume to be added the |entries|. 176 TargetVolume volume; 177 178 // Entries to be added. 179 ScopedVector<TestEntryInfo> entries; 180 181 // Registers the member information to the given converter. 182 static void RegisterJSONConverter( 183 base::JSONValueConverter<AddEntriesMessage>* converter); 184}; 185 186// static 187void AddEntriesMessage::RegisterJSONConverter( 188 base::JSONValueConverter<AddEntriesMessage>* converter) { 189 converter->RegisterCustomField("volume", 190 &AddEntriesMessage::volume, 191 &MapStringToTargetVolume); 192 converter->RegisterRepeatedMessage<TestEntryInfo>( 193 "entries", 194 &AddEntriesMessage::entries); 195} 196 197// Test volume. 198class TestVolume { 199 protected: 200 explicit TestVolume(const std::string& name) : name_(name) {} 201 virtual ~TestVolume() {} 202 203 bool CreateRootDirectory(const Profile* profile) { 204 const base::FilePath path = profile->GetPath().Append(name_); 205 return root_.path() == path || root_.Set(path); 206 } 207 208 const std::string& name() { return name_; } 209 const base::FilePath root_path() { return root_.path(); } 210 211 private: 212 std::string name_; 213 base::ScopedTempDir root_; 214}; 215 216// The local volume class for test. 217// This class provides the operations for a test volume that simulates local 218// drive. 219class LocalTestVolume : public TestVolume { 220 public: 221 explicit LocalTestVolume(const std::string& name) : TestVolume(name) {} 222 virtual ~LocalTestVolume() {} 223 224 // Adds this volume to the file system as a local volume. Returns true on 225 // success. 226 virtual bool Mount(Profile* profile) = 0; 227 228 void CreateEntry(const TestEntryInfo& entry) { 229 const base::FilePath target_path = 230 root_path().AppendASCII(entry.target_path); 231 232 entries_.insert(std::make_pair(target_path, entry)); 233 switch (entry.type) { 234 case FILE: { 235 const base::FilePath source_path = 236 google_apis::test_util::GetTestFilePath("chromeos/file_manager"). 237 AppendASCII(entry.source_file_name); 238 ASSERT_TRUE(base::CopyFile(source_path, target_path)) 239 << "Copy from " << source_path.value() 240 << " to " << target_path.value() << " failed."; 241 break; 242 } 243 case DIRECTORY: 244 ASSERT_TRUE(base::CreateDirectory(target_path)) << 245 "Failed to create a directory: " << target_path.value(); 246 break; 247 } 248 ASSERT_TRUE(UpdateModifiedTime(entry)); 249 } 250 251 private: 252 // Updates ModifiedTime of the entry and its parents by referring 253 // TestEntryInfo. Returns true on success. 254 bool UpdateModifiedTime(const TestEntryInfo& entry) { 255 const base::FilePath path = root_path().AppendASCII(entry.target_path); 256 if (!base::TouchFile(path, entry.last_modified_time, 257 entry.last_modified_time)) 258 return false; 259 260 // Update the modified time of parent directories because it may be also 261 // affected by the update of child items. 262 if (path.DirName() != root_path()) { 263 const std::map<base::FilePath, const TestEntryInfo>::iterator it = 264 entries_.find(path.DirName()); 265 if (it == entries_.end()) 266 return false; 267 return UpdateModifiedTime(it->second); 268 } 269 return true; 270 } 271 272 std::map<base::FilePath, const TestEntryInfo> entries_; 273}; 274 275class DownloadsTestVolume : public LocalTestVolume { 276 public: 277 DownloadsTestVolume() : LocalTestVolume("Downloads") {} 278 virtual ~DownloadsTestVolume() {} 279 280 virtual bool Mount(Profile* profile) OVERRIDE { 281 return CreateRootDirectory(profile) && 282 VolumeManager::Get(profile) 283 ->RegisterDownloadsDirectoryForTesting(root_path()); 284 } 285}; 286 287// Test volume for mimicing a specified type of volumes by a local folder. 288class FakeTestVolume : public LocalTestVolume { 289 public: 290 FakeTestVolume(const std::string& name, 291 VolumeType volume_type, 292 chromeos::DeviceType device_type) 293 : LocalTestVolume(name), 294 volume_type_(volume_type), 295 device_type_(device_type) {} 296 virtual ~FakeTestVolume() {} 297 298 // Simple test entries used for testing, e.g., read-only volumes. 299 bool PrepareTestEntries(Profile* profile) { 300 if (!CreateRootDirectory(profile)) 301 return false; 302 // Must be in sync with BASIC_FAKE_ENTRY_SET in the JS test code. 303 CreateEntry( 304 TestEntryInfo(FILE, "text.txt", "hello.txt", "text/plain", NONE, 305 base::Time::Now())); 306 CreateEntry( 307 TestEntryInfo(DIRECTORY, std::string(), "A", std::string(), NONE, 308 base::Time::Now())); 309 return true; 310 } 311 312 virtual bool Mount(Profile* profile) OVERRIDE { 313 if (!CreateRootDirectory(profile)) 314 return false; 315 storage::ExternalMountPoints* const mount_points = 316 storage::ExternalMountPoints::GetSystemInstance(); 317 318 // First revoke the existing mount point (if any). 319 mount_points->RevokeFileSystem(name()); 320 const bool result = 321 mount_points->RegisterFileSystem(name(), 322 storage::kFileSystemTypeNativeLocal, 323 storage::FileSystemMountOption(), 324 root_path()); 325 if (!result) 326 return false; 327 328 VolumeManager::Get(profile)->AddVolumeInfoForTesting( 329 root_path(), volume_type_, device_type_); 330 return true; 331 } 332 333 private: 334 const VolumeType volume_type_; 335 const chromeos::DeviceType device_type_; 336}; 337 338// The drive volume class for test. 339// This class provides the operations for a test volume that simulates Google 340// drive. 341class DriveTestVolume : public TestVolume { 342 public: 343 DriveTestVolume() : TestVolume("drive"), integration_service_(NULL) {} 344 virtual ~DriveTestVolume() {} 345 346 void CreateEntry(const TestEntryInfo& entry) { 347 const base::FilePath path = 348 base::FilePath::FromUTF8Unsafe(entry.target_path); 349 const std::string target_name = path.BaseName().AsUTF8Unsafe(); 350 351 // Obtain the parent entry. 352 drive::FileError error = drive::FILE_ERROR_OK; 353 scoped_ptr<drive::ResourceEntry> parent_entry(new drive::ResourceEntry); 354 integration_service_->file_system()->GetResourceEntry( 355 drive::util::GetDriveMyDriveRootPath().Append(path).DirName(), 356 google_apis::test_util::CreateCopyResultCallback( 357 &error, &parent_entry)); 358 content::RunAllBlockingPoolTasksUntilIdle(); 359 ASSERT_EQ(drive::FILE_ERROR_OK, error); 360 ASSERT_TRUE(parent_entry); 361 362 switch (entry.type) { 363 case FILE: 364 CreateFile(entry.source_file_name, 365 parent_entry->resource_id(), 366 target_name, 367 entry.mime_type, 368 entry.shared_option == SHARED, 369 entry.last_modified_time); 370 break; 371 case DIRECTORY: 372 CreateDirectory( 373 parent_entry->resource_id(), target_name, entry.last_modified_time); 374 break; 375 } 376 } 377 378 // Creates an empty directory with the given |name| and |modification_time|. 379 void CreateDirectory(const std::string& parent_id, 380 const std::string& target_name, 381 const base::Time& modification_time) { 382 google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR; 383 scoped_ptr<google_apis::FileResource> entry; 384 fake_drive_service_->AddNewDirectory( 385 parent_id, 386 target_name, 387 drive::DriveServiceInterface::AddNewDirectoryOptions(), 388 google_apis::test_util::CreateCopyResultCallback(&error, &entry)); 389 base::MessageLoop::current()->RunUntilIdle(); 390 ASSERT_EQ(google_apis::HTTP_CREATED, error); 391 ASSERT_TRUE(entry); 392 393 fake_drive_service_->SetLastModifiedTime( 394 entry->file_id(), 395 modification_time, 396 google_apis::test_util::CreateCopyResultCallback(&error, &entry)); 397 base::MessageLoop::current()->RunUntilIdle(); 398 ASSERT_TRUE(error == google_apis::HTTP_SUCCESS); 399 ASSERT_TRUE(entry); 400 CheckForUpdates(); 401 } 402 403 // Creates a test file with the given spec. 404 // Serves |test_file_name| file. Pass an empty string for an empty file. 405 void CreateFile(const std::string& source_file_name, 406 const std::string& parent_id, 407 const std::string& target_name, 408 const std::string& mime_type, 409 bool shared_with_me, 410 const base::Time& modification_time) { 411 google_apis::GDataErrorCode error = google_apis::GDATA_OTHER_ERROR; 412 413 std::string content_data; 414 if (!source_file_name.empty()) { 415 base::FilePath source_file_path = 416 google_apis::test_util::GetTestFilePath("chromeos/file_manager"). 417 AppendASCII(source_file_name); 418 ASSERT_TRUE(base::ReadFileToString(source_file_path, &content_data)); 419 } 420 421 scoped_ptr<google_apis::FileResource> entry; 422 fake_drive_service_->AddNewFile( 423 mime_type, 424 content_data, 425 parent_id, 426 target_name, 427 shared_with_me, 428 google_apis::test_util::CreateCopyResultCallback(&error, &entry)); 429 base::MessageLoop::current()->RunUntilIdle(); 430 ASSERT_EQ(google_apis::HTTP_CREATED, error); 431 ASSERT_TRUE(entry); 432 433 fake_drive_service_->SetLastModifiedTime( 434 entry->file_id(), 435 modification_time, 436 google_apis::test_util::CreateCopyResultCallback(&error, &entry)); 437 base::MessageLoop::current()->RunUntilIdle(); 438 ASSERT_EQ(google_apis::HTTP_SUCCESS, error); 439 ASSERT_TRUE(entry); 440 441 CheckForUpdates(); 442 } 443 444 // Notifies FileSystem that the contents in FakeDriveService are 445 // changed, hence the new contents should be fetched. 446 void CheckForUpdates() { 447 if (integration_service_ && integration_service_->file_system()) { 448 integration_service_->file_system()->CheckForUpdates(); 449 } 450 } 451 452 // Sets the url base for the test server to be used to generate share urls 453 // on the files and directories. 454 void ConfigureShareUrlBase(const GURL& share_url_base) { 455 fake_drive_service_->set_share_url_base(share_url_base); 456 } 457 458 drive::DriveIntegrationService* CreateDriveIntegrationService( 459 Profile* profile) { 460 profile_ = profile; 461 fake_drive_service_ = new drive::FakeDriveService; 462 fake_drive_service_->LoadAppListForDriveApi("drive/applist.json"); 463 464 if (!CreateRootDirectory(profile)) 465 return NULL; 466 integration_service_ = new drive::DriveIntegrationService( 467 profile, NULL, fake_drive_service_, std::string(), root_path(), NULL); 468 return integration_service_; 469 } 470 471 private: 472 Profile* profile_; 473 drive::FakeDriveService* fake_drive_service_; 474 drive::DriveIntegrationService* integration_service_; 475}; 476 477// Listener to obtain the test relative messages synchronously. 478class FileManagerTestListener : public content::NotificationObserver { 479 public: 480 struct Message { 481 int type; 482 std::string message; 483 scoped_refptr<extensions::TestSendMessageFunction> function; 484 }; 485 486 FileManagerTestListener() { 487 registrar_.Add(this, 488 extensions::NOTIFICATION_EXTENSION_TEST_PASSED, 489 content::NotificationService::AllSources()); 490 registrar_.Add(this, 491 extensions::NOTIFICATION_EXTENSION_TEST_FAILED, 492 content::NotificationService::AllSources()); 493 registrar_.Add(this, 494 extensions::NOTIFICATION_EXTENSION_TEST_MESSAGE, 495 content::NotificationService::AllSources()); 496 } 497 498 Message GetNextMessage() { 499 if (messages_.empty()) 500 content::RunMessageLoop(); 501 const Message entry = messages_.front(); 502 messages_.pop_front(); 503 return entry; 504 } 505 506 virtual void Observe(int type, 507 const content::NotificationSource& source, 508 const content::NotificationDetails& details) OVERRIDE { 509 Message entry; 510 entry.type = type; 511 entry.message = type != extensions::NOTIFICATION_EXTENSION_TEST_PASSED 512 ? *content::Details<std::string>(details).ptr() 513 : std::string(); 514 entry.function = 515 type == extensions::NOTIFICATION_EXTENSION_TEST_MESSAGE 516 ? content::Source<extensions::TestSendMessageFunction>(source).ptr() 517 : NULL; 518 messages_.push_back(entry); 519 base::MessageLoopForUI::current()->Quit(); 520 } 521 522 private: 523 std::deque<Message> messages_; 524 content::NotificationRegistrar registrar_; 525}; 526 527// The base test class. 528class FileManagerBrowserTestBase : public ExtensionApiTest { 529 protected: 530 virtual void SetUpInProcessBrowserTestFixture() OVERRIDE; 531 532 virtual void SetUpOnMainThread() OVERRIDE; 533 534 // Adds an incognito and guest-mode flags for tests in the guest mode. 535 virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE; 536 537 // Loads our testing extension and sends it a string identifying the current 538 // test. 539 virtual void StartTest(); 540 void RunTestMessageLoop(); 541 542 // Overriding point for test configurations. 543 virtual const char* GetTestManifestName() const { 544 return "file_manager_test_manifest.json"; 545 } 546 virtual GuestMode GetGuestModeParam() const = 0; 547 virtual const char* GetTestCaseNameParam() const = 0; 548 virtual std::string OnMessage(const std::string& name, 549 const base::Value* value); 550 551 scoped_ptr<LocalTestVolume> local_volume_; 552 linked_ptr<DriveTestVolume> drive_volume_; 553 std::map<Profile*, linked_ptr<DriveTestVolume> > drive_volumes_; 554 scoped_ptr<FakeTestVolume> usb_volume_; 555 scoped_ptr<FakeTestVolume> mtp_volume_; 556 557 private: 558 drive::DriveIntegrationService* CreateDriveIntegrationService( 559 Profile* profile); 560 DriveIntegrationServiceFactory::FactoryCallback 561 create_drive_integration_service_; 562 scoped_ptr<DriveIntegrationServiceFactory::ScopedFactoryForTest> 563 service_factory_for_test_; 564}; 565 566void FileManagerBrowserTestBase::SetUpInProcessBrowserTestFixture() { 567 ExtensionApiTest::SetUpInProcessBrowserTestFixture(); 568 extensions::ComponentLoader::EnableBackgroundExtensionsForTesting(); 569 570 local_volume_.reset(new DownloadsTestVolume); 571 if (GetGuestModeParam() != IN_GUEST_MODE) { 572 create_drive_integration_service_ = 573 base::Bind(&FileManagerBrowserTestBase::CreateDriveIntegrationService, 574 base::Unretained(this)); 575 service_factory_for_test_.reset( 576 new DriveIntegrationServiceFactory::ScopedFactoryForTest( 577 &create_drive_integration_service_)); 578 } 579} 580 581void FileManagerBrowserTestBase::SetUpOnMainThread() { 582 ExtensionApiTest::SetUpOnMainThread(); 583 ASSERT_TRUE(local_volume_->Mount(profile())); 584 585 if (GetGuestModeParam() != IN_GUEST_MODE) { 586 // Install the web server to serve the mocked share dialog. 587 ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady()); 588 const GURL share_url_base(embedded_test_server()->GetURL( 589 "/chromeos/file_manager/share_dialog_mock/index.html")); 590 drive_volume_ = drive_volumes_[profile()->GetOriginalProfile()]; 591 drive_volume_->ConfigureShareUrlBase(share_url_base); 592 test_util::WaitUntilDriveMountPointIsAdded(profile()); 593 } 594} 595 596void FileManagerBrowserTestBase::SetUpCommandLine(CommandLine* command_line) { 597 if (GetGuestModeParam() == IN_GUEST_MODE) { 598 command_line->AppendSwitch(chromeos::switches::kGuestSession); 599 command_line->AppendSwitchNative(chromeos::switches::kLoginUser, ""); 600 command_line->AppendSwitch(switches::kIncognito); 601 } 602 if (GetGuestModeParam() == IN_INCOGNITO) { 603 command_line->AppendSwitch(switches::kIncognito); 604 } 605 ExtensionApiTest::SetUpCommandLine(command_line); 606} 607 608void FileManagerBrowserTestBase::StartTest() { 609 // Launch the extension. 610 const base::FilePath path = 611 test_data_dir_.AppendASCII("file_manager_browsertest"); 612 const extensions::Extension* const extension = 613 LoadExtensionAsComponentWithManifest(path, GetTestManifestName()); 614 ASSERT_TRUE(extension); 615 616 RunTestMessageLoop(); 617} 618 619void FileManagerBrowserTestBase::RunTestMessageLoop() { 620 // Handle the messages from JavaScript. 621 // The while loop is break when the test is passed or failed. 622 FileManagerTestListener listener; 623 while (true) { 624 FileManagerTestListener::Message entry = listener.GetNextMessage(); 625 if (entry.type == extensions::NOTIFICATION_EXTENSION_TEST_PASSED) { 626 // Test succeed. 627 break; 628 } else if (entry.type == extensions::NOTIFICATION_EXTENSION_TEST_FAILED) { 629 // Test failed. 630 ADD_FAILURE() << entry.message; 631 break; 632 } 633 634 // Parse the message value as JSON. 635 const scoped_ptr<const base::Value> value( 636 base::JSONReader::Read(entry.message)); 637 638 // If the message is not the expected format, just ignore it. 639 const base::DictionaryValue* message_dictionary = NULL; 640 std::string name; 641 if (!value || !value->GetAsDictionary(&message_dictionary) || 642 !message_dictionary->GetString("name", &name)) 643 continue; 644 645 entry.function->Reply(OnMessage(name, value.get())); 646 } 647} 648 649std::string FileManagerBrowserTestBase::OnMessage(const std::string& name, 650 const base::Value* value) { 651 if (name == "getTestName") { 652 // Pass the test case name. 653 return GetTestCaseNameParam(); 654 } else if (name == "getRootPaths") { 655 // Pass the root paths. 656 const scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue()); 657 res->SetString("downloads", 658 "/" + util::GetDownloadsMountPointName(profile())); 659 res->SetString("drive", 660 "/" + drive::util::GetDriveMountPointPath(profile() 661 ).BaseName().AsUTF8Unsafe() + "/root"); 662 std::string jsonString; 663 base::JSONWriter::Write(res.get(), &jsonString); 664 return jsonString; 665 } else if (name == "isInGuestMode") { 666 // Obtain whether the test is in guest mode or not. 667 return GetGuestModeParam() != NOT_IN_GUEST_MODE ? "true" : "false"; 668 } else if (name == "getCwsWidgetContainerMockUrl") { 669 // Obtain whether the test is in guest mode or not. 670 const GURL url = embedded_test_server()->GetURL( 671 "/chromeos/file_manager/cws_container_mock/index.html"); 672 std::string origin = url.GetOrigin().spec(); 673 674 // Removes trailing a slash. 675 if (*origin.rbegin() == '/') 676 origin.resize(origin.length() - 1); 677 678 const scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue()); 679 res->SetString("url", url.spec()); 680 res->SetString("origin", origin); 681 std::string jsonString; 682 base::JSONWriter::Write(res.get(), &jsonString); 683 return jsonString; 684 } else if (name == "addEntries") { 685 // Add entries to the specified volume. 686 base::JSONValueConverter<AddEntriesMessage> add_entries_message_converter; 687 AddEntriesMessage message; 688 if (!add_entries_message_converter.Convert(*value, &message)) 689 return "onError"; 690 for (size_t i = 0; i < message.entries.size(); ++i) { 691 switch (message.volume) { 692 case LOCAL_VOLUME: 693 local_volume_->CreateEntry(*message.entries[i]); 694 break; 695 case DRIVE_VOLUME: 696 if (drive_volume_.get()) 697 drive_volume_->CreateEntry(*message.entries[i]); 698 break; 699 case USB_VOLUME: 700 if (usb_volume_) 701 usb_volume_->CreateEntry(*message.entries[i]); 702 break; 703 default: 704 NOTREACHED(); 705 break; 706 } 707 } 708 return "onEntryAdded"; 709 } else if (name == "mountFakeUsb") { 710 usb_volume_.reset(new FakeTestVolume("fake-usb", 711 VOLUME_TYPE_REMOVABLE_DISK_PARTITION, 712 chromeos::DEVICE_TYPE_USB)); 713 usb_volume_->Mount(profile()); 714 return "true"; 715 } else if (name == "mountFakeMtp") { 716 mtp_volume_.reset(new FakeTestVolume("fake-mtp", 717 VOLUME_TYPE_MTP, 718 chromeos::DEVICE_TYPE_UNKNOWN)); 719 if (!mtp_volume_->PrepareTestEntries(profile())) 720 return "false"; 721 mtp_volume_->Mount(profile()); 722 return "true"; 723 } 724 return "unknownMessage"; 725} 726 727drive::DriveIntegrationService* 728FileManagerBrowserTestBase::CreateDriveIntegrationService(Profile* profile) { 729 drive_volumes_[profile->GetOriginalProfile()].reset(new DriveTestVolume()); 730 return drive_volumes_[profile->GetOriginalProfile()]-> 731 CreateDriveIntegrationService(profile); 732} 733 734// Parameter of FileManagerBrowserTest. 735// The second value is the case name of JavaScript. 736typedef std::tr1::tuple<GuestMode, const char*> TestParameter; 737 738// Test fixture class for normal (not multi-profile related) tests. 739class FileManagerBrowserTest : 740 public FileManagerBrowserTestBase, 741 public ::testing::WithParamInterface<TestParameter> { 742 virtual GuestMode GetGuestModeParam() const OVERRIDE { 743 return std::tr1::get<0>(GetParam()); 744 } 745 virtual const char* GetTestCaseNameParam() const OVERRIDE { 746 return std::tr1::get<1>(GetParam()); 747 } 748}; 749 750IN_PROC_BROWSER_TEST_P(FileManagerBrowserTest, Test) { 751 StartTest(); 752} 753 754// Unlike TEST/TEST_F, which are macros that expand to further macros, 755// INSTANTIATE_TEST_CASE_P is a macro that expands directly to code that 756// stringizes the arguments. As a result, macros passed as parameters (such as 757// prefix or test_case_name) will not be expanded by the preprocessor. To work 758// around this, indirect the macro for INSTANTIATE_TEST_CASE_P, so that the 759// pre-processor will expand macros such as MAYBE_test_name before 760// instantiating the test. 761#define WRAPPED_INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator) \ 762 INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator) 763 764// Slow tests are disabled on debug build. http://crbug.com/327719 765#if !defined(NDEBUG) 766#define MAYBE_FileDisplay DISABLED_FileDisplay 767#else 768#define MAYBE_FileDisplay FileDisplay 769#endif 770WRAPPED_INSTANTIATE_TEST_CASE_P( 771 MAYBE_FileDisplay, 772 FileManagerBrowserTest, 773 ::testing::Values(TestParameter(NOT_IN_GUEST_MODE, "fileDisplayDownloads"), 774 TestParameter(IN_GUEST_MODE, "fileDisplayDownloads"), 775 TestParameter(NOT_IN_GUEST_MODE, "fileDisplayDrive"), 776 TestParameter(NOT_IN_GUEST_MODE, "fileDisplayMtp"))); 777 778// http://crbug.com/327719 779WRAPPED_INSTANTIATE_TEST_CASE_P( 780 DISABLED_OpenZipFiles, 781 FileManagerBrowserTest, 782 ::testing::Values(TestParameter(IN_GUEST_MODE, "zipOpenDownloads"), 783 TestParameter(NOT_IN_GUEST_MODE, "zipOpenDownloads"), 784 TestParameter(NOT_IN_GUEST_MODE, "zipOpenDrive"))); 785 786// Slow tests are disabled on debug build. http://crbug.com/327719 787#if !defined(NDEBUG) 788#define MAYBE_OpenVideoFiles DISABLED_OpenVideoFiles 789#else 790#define MAYBE_OpenVideoFiles OpenVideoFiles 791#endif 792WRAPPED_INSTANTIATE_TEST_CASE_P( 793 MAYBE_OpenVideoFiles, 794 FileManagerBrowserTest, 795 ::testing::Values(TestParameter(IN_GUEST_MODE, "videoOpenDownloads"), 796 TestParameter(NOT_IN_GUEST_MODE, "videoOpenDownloads"), 797 TestParameter(NOT_IN_GUEST_MODE, "videoOpenDrive"))); 798 799// Slow tests are disabled on debug build. http://crbug.com/327719 800#if !defined(NDEBUG) 801#define MAYBE_OpenAudioFiles DISABLED_OpenAudioFiles 802#else 803#define MAYBE_OpenAudioFiles OpenAudioFiles 804#endif 805WRAPPED_INSTANTIATE_TEST_CASE_P( 806 MAYBE_OpenAudioFiles, 807 FileManagerBrowserTest, 808 ::testing::Values( 809 TestParameter(IN_GUEST_MODE, "audioOpenDownloads"), 810 TestParameter(NOT_IN_GUEST_MODE, "audioOpenDownloads"), 811 TestParameter(NOT_IN_GUEST_MODE, "audioOpenDrive"), 812 TestParameter(NOT_IN_GUEST_MODE, "audioAutoAdvanceDrive"), 813 TestParameter(NOT_IN_GUEST_MODE, "audioRepeatSingleFileDrive"), 814 TestParameter(NOT_IN_GUEST_MODE, "audioNoRepeatSingleFileDrive"), 815 TestParameter(NOT_IN_GUEST_MODE, "audioRepeatMultipleFileDrive"), 816 TestParameter(NOT_IN_GUEST_MODE, "audioNoRepeatMultipleFileDrive"))); 817 818// Slow tests are disabled on debug build. http://crbug.com/327719 819#if !defined(NDEBUG) 820#define MAYBE_CreateNewFolder DISABLED_CreateNewFolder 821#else 822#define MAYBE_CreateNewFolder CreateNewFolder 823#endif 824WRAPPED_INSTANTIATE_TEST_CASE_P( 825 MAYBE_CreateNewFolder, 826 FileManagerBrowserTest, 827 ::testing::Values(TestParameter(NOT_IN_GUEST_MODE, 828 "createNewFolderAfterSelectFile"), 829 TestParameter(IN_GUEST_MODE, 830 "createNewFolderDownloads"), 831 TestParameter(NOT_IN_GUEST_MODE, 832 "createNewFolderDownloads"), 833 TestParameter(NOT_IN_GUEST_MODE, 834 "createNewFolderDrive"))); 835 836// Slow tests are disabled on debug build. http://crbug.com/327719 837#if !defined(NDEBUG) 838#define MAYBE_KeyboardOperations DISABLED_KeyboardOperations 839#else 840#define MAYBE_KeyboardOperations KeyboardOperations 841#endif 842WRAPPED_INSTANTIATE_TEST_CASE_P( 843 MAYBE_KeyboardOperations, 844 FileManagerBrowserTest, 845 ::testing::Values(TestParameter(IN_GUEST_MODE, "keyboardDeleteDownloads"), 846 TestParameter(NOT_IN_GUEST_MODE, 847 "keyboardDeleteDownloads"), 848 TestParameter(NOT_IN_GUEST_MODE, "keyboardDeleteDrive"), 849 TestParameter(IN_GUEST_MODE, "keyboardCopyDownloads"), 850 TestParameter(NOT_IN_GUEST_MODE, "keyboardCopyDownloads"), 851 TestParameter(NOT_IN_GUEST_MODE, "keyboardCopyDrive"), 852 TestParameter(IN_GUEST_MODE, "renameFileDownloads"), 853 TestParameter(NOT_IN_GUEST_MODE, "renameFileDownloads"), 854 TestParameter(NOT_IN_GUEST_MODE, "renameFileDrive"))); 855 856// Slow tests are disabled on debug build. http://crbug.com/327719 857#if !defined(NDEBUG) 858#define MAYBE_DriveSpecific DISABLED_DriveSpecific 859#else 860#define MAYBE_DriveSpecific DriveSpecific 861#endif 862WRAPPED_INSTANTIATE_TEST_CASE_P( 863 MAYBE_DriveSpecific, 864 FileManagerBrowserTest, 865 ::testing::Values(TestParameter(NOT_IN_GUEST_MODE, "openSidebarRecent"), 866 TestParameter(NOT_IN_GUEST_MODE, "openSidebarOffline"), 867 TestParameter(NOT_IN_GUEST_MODE, 868 "openSidebarSharedWithMe"), 869 TestParameter(NOT_IN_GUEST_MODE, "autocomplete"))); 870 871// Slow tests are disabled on debug build. http://crbug.com/327719 872#if !defined(NDEBUG) 873#define MAYBE_Transfer DISABLED_Transfer 874#else 875#define MAYBE_Transfer Transfer 876#endif 877WRAPPED_INSTANTIATE_TEST_CASE_P( 878 MAYBE_Transfer, 879 FileManagerBrowserTest, 880 ::testing::Values( 881 TestParameter(NOT_IN_GUEST_MODE, "transferFromDriveToDownloads"), 882 TestParameter(NOT_IN_GUEST_MODE, "transferFromDownloadsToDrive"), 883 TestParameter(NOT_IN_GUEST_MODE, "transferFromSharedToDownloads"), 884 TestParameter(NOT_IN_GUEST_MODE, "transferFromSharedToDrive"), 885 TestParameter(NOT_IN_GUEST_MODE, "transferFromRecentToDownloads"), 886 TestParameter(NOT_IN_GUEST_MODE, "transferFromRecentToDrive"), 887 TestParameter(NOT_IN_GUEST_MODE, "transferFromOfflineToDownloads"), 888 TestParameter(NOT_IN_GUEST_MODE, "transferFromOfflineToDrive"))); 889 890// Slow tests are disabled on debug build. http://crbug.com/327719 891#if !defined(NDEBUG) 892#define MAYBE_RestorePrefs DISABLED_RestorePrefs 893#else 894#define MAYBE_RestorePrefs RestorePrefs 895#endif 896WRAPPED_INSTANTIATE_TEST_CASE_P( 897 MAYBE_RestorePrefs, 898 FileManagerBrowserTest, 899 ::testing::Values(TestParameter(IN_GUEST_MODE, "restoreSortColumn"), 900 TestParameter(NOT_IN_GUEST_MODE, "restoreSortColumn"), 901 TestParameter(IN_GUEST_MODE, "restoreCurrentView"), 902 TestParameter(NOT_IN_GUEST_MODE, "restoreCurrentView"))); 903 904// Slow tests are disabled on debug build. http://crbug.com/327719 905#if !defined(NDEBUG) 906#define MAYBE_ShareDialog DISABLED_ShareDialog 907#else 908#define MAYBE_ShareDialog ShareDialog 909#endif 910WRAPPED_INSTANTIATE_TEST_CASE_P( 911 MAYBE_ShareDialog, 912 FileManagerBrowserTest, 913 ::testing::Values(TestParameter(NOT_IN_GUEST_MODE, "shareFile"), 914 TestParameter(NOT_IN_GUEST_MODE, "shareDirectory"))); 915 916// Slow tests are disabled on debug build. http://crbug.com/327719 917#if !defined(NDEBUG) 918#define MAYBE_RestoreGeometry DISABLED_RestoreGeometry 919#else 920#define MAYBE_RestoreGeometry RestoreGeometry 921#endif 922WRAPPED_INSTANTIATE_TEST_CASE_P( 923 MAYBE_RestoreGeometry, 924 FileManagerBrowserTest, 925 ::testing::Values(TestParameter(NOT_IN_GUEST_MODE, "restoreGeometry"), 926 TestParameter(IN_GUEST_MODE, "restoreGeometry"))); 927 928// Slow tests are disabled on debug build. http://crbug.com/327719 929#if !defined(NDEBUG) 930#define MAYBE_Traverse DISABLED_Traverse 931#else 932#define MAYBE_Traverse Traverse 933#endif 934WRAPPED_INSTANTIATE_TEST_CASE_P( 935 MAYBE_Traverse, 936 FileManagerBrowserTest, 937 ::testing::Values(TestParameter(IN_GUEST_MODE, "traverseDownloads"), 938 TestParameter(NOT_IN_GUEST_MODE, "traverseDownloads"), 939 TestParameter(NOT_IN_GUEST_MODE, "traverseDrive"))); 940 941// Slow tests are disabled on debug build. http://crbug.com/327719 942#if !defined(NDEBUG) 943#define MAYBE_SuggestAppDialog DISABLED_SuggestAppDialog 944#else 945#define MAYBE_SuggestAppDialog SuggestAppDialog 946#endif 947WRAPPED_INSTANTIATE_TEST_CASE_P( 948 MAYBE_SuggestAppDialog, 949 FileManagerBrowserTest, 950 ::testing::Values(TestParameter(NOT_IN_GUEST_MODE, "suggestAppDialog"))); 951 952// Slow tests are disabled on debug build. http://crbug.com/327719 953#if !defined(NDEBUG) 954#define MAYBE_ExecuteDefaultTaskOnDownloads \ 955 DISABLED_ExecuteDefaultTaskOnDownloads 956#else 957#define MAYBE_ExecuteDefaultTaskOnDownloads ExecuteDefaultTaskOnDownloads 958#endif 959WRAPPED_INSTANTIATE_TEST_CASE_P( 960 MAYBE_ExecuteDefaultTaskOnDownloads, 961 FileManagerBrowserTest, 962 ::testing::Values( 963 TestParameter(NOT_IN_GUEST_MODE, "executeDefaultTaskOnDownloads"), 964 TestParameter(IN_GUEST_MODE, "executeDefaultTaskOnDownloads"))); 965 966// Slow tests are disabled on debug build. http://crbug.com/327719 967#if !defined(NDEBUG) 968#define MAYBE_ExecuteDefaultTaskOnDrive DISABLED_ExecuteDefaultTaskOnDrive 969#else 970#define MAYBE_ExecuteDefaultTaskOnDrive ExecuteDefaultTaskOnDrive 971#endif 972INSTANTIATE_TEST_CASE_P( 973 MAYBE_ExecuteDefaultTaskOnDrive, 974 FileManagerBrowserTest, 975 ::testing::Values( 976 TestParameter(NOT_IN_GUEST_MODE, "executeDefaultTaskOnDrive"))); 977 978// Slow tests are disabled on debug build. http://crbug.com/327719 979#if !defined(NDEBUG) 980#define MAYBE_DefaultActionDialog DISABLED_DefaultActionDialog 981#else 982#define MAYBE_DefaultActionDialog DefaultActionDialog 983#endif 984WRAPPED_INSTANTIATE_TEST_CASE_P( 985 MAYBE_DefaultActionDialog, 986 FileManagerBrowserTest, 987 ::testing::Values( 988 TestParameter(NOT_IN_GUEST_MODE, "defaultActionDialogOnDownloads"), 989 TestParameter(IN_GUEST_MODE, "defaultActionDialogOnDownloads"), 990 TestParameter(NOT_IN_GUEST_MODE, "defaultActionDialogOnDrive"))); 991 992// Slow tests are disabled on debug build. http://crbug.com/327719 993#if !defined(NDEBUG) 994#define MAYBE_FolderShortcuts DISABLED_FolderShortcuts 995#else 996#define MAYBE_FolderShortcuts FolderShortcuts 997#endif 998WRAPPED_INSTANTIATE_TEST_CASE_P( 999 MAYBE_FolderShortcuts, 1000 FileManagerBrowserTest, 1001 ::testing::Values( 1002 TestParameter(NOT_IN_GUEST_MODE, "traverseFolderShortcuts"), 1003 TestParameter(NOT_IN_GUEST_MODE, "addRemoveFolderShortcuts"))); 1004 1005INSTANTIATE_TEST_CASE_P( 1006 TabIndex, 1007 FileManagerBrowserTest, 1008 ::testing::Values(TestParameter(NOT_IN_GUEST_MODE, "searchBoxFocus"))); 1009 1010// Slow tests are disabled on debug build. http://crbug.com/327719 1011#if !defined(NDEBUG) 1012#define MAYBE_Thumbnails DISABLED_Thumbnails 1013#else 1014#define MAYBE_Thumbnails Thumbnails 1015#endif 1016WRAPPED_INSTANTIATE_TEST_CASE_P( 1017 MAYBE_Thumbnails, 1018 FileManagerBrowserTest, 1019 ::testing::Values(TestParameter(NOT_IN_GUEST_MODE, "thumbnailsDownloads"), 1020 TestParameter(IN_GUEST_MODE, "thumbnailsDownloads"))); 1021 1022#if !defined(NDEBUG) 1023#define MAYBE_OpenFileDialog DISABLED_OpenFileDialog 1024#else 1025#define MAYBE_OpenFileDialog OpenFileDialog 1026#endif 1027WRAPPED_INSTANTIATE_TEST_CASE_P( 1028 MAYBE_OpenFileDialog, 1029 FileManagerBrowserTest, 1030 ::testing::Values(TestParameter(NOT_IN_GUEST_MODE, 1031 "openFileDialogOnDownloads"), 1032 TestParameter(IN_GUEST_MODE, 1033 "openFileDialogOnDownloads"), 1034 TestParameter(NOT_IN_GUEST_MODE, 1035 "openFileDialogOnDrive"), 1036 TestParameter(IN_INCOGNITO, 1037 "openFileDialogOnDownloads"), 1038 TestParameter(IN_INCOGNITO, 1039 "openFileDialogOnDrive"))); 1040 1041// Slow tests are disabled on debug build. http://crbug.com/327719 1042#if !defined(NDEBUG) 1043#define MAYBE_CopyBetweenWindows DISABLED_CopyBetweenWindows 1044#else 1045#define MAYBE_CopyBetweenWindows CopyBetweenWindows 1046#endif 1047WRAPPED_INSTANTIATE_TEST_CASE_P( 1048 MAYBE_CopyBetweenWindows, 1049 FileManagerBrowserTest, 1050 ::testing::Values( 1051 TestParameter(NOT_IN_GUEST_MODE, "copyBetweenWindowsLocalToDrive"), 1052 TestParameter(NOT_IN_GUEST_MODE, "copyBetweenWindowsLocalToUsb"), 1053 TestParameter(NOT_IN_GUEST_MODE, "copyBetweenWindowsUsbToDrive"), 1054 TestParameter(NOT_IN_GUEST_MODE, "copyBetweenWindowsDriveToLocal"), 1055 TestParameter(NOT_IN_GUEST_MODE, "copyBetweenWindowsDriveToUsb"), 1056 TestParameter(NOT_IN_GUEST_MODE, "copyBetweenWindowsUsbToLocal"))); 1057 1058// Slow tests are disabled on debug build. http://crbug.com/327719 1059#if !defined(NDEBUG) 1060#define MAYBE_ShowGridView DISABLED_ShowGridView 1061#else 1062#define MAYBE_ShowGridView ShowGridView 1063#endif 1064WRAPPED_INSTANTIATE_TEST_CASE_P( 1065 MAYBE_ShowGridView, 1066 FileManagerBrowserTest, 1067 ::testing::Values(TestParameter(NOT_IN_GUEST_MODE, "showGridViewDownloads"), 1068 TestParameter(IN_GUEST_MODE, "showGridViewDownloads"), 1069 TestParameter(NOT_IN_GUEST_MODE, "showGridViewDrive"))); 1070 1071// Structure to describe an account info. 1072struct TestAccountInfo { 1073 const char* const email; 1074 const char* const hash; 1075 const char* const display_name; 1076}; 1077 1078enum { 1079 DUMMY_ACCOUNT_INDEX = 0, 1080 PRIMARY_ACCOUNT_INDEX = 1, 1081 SECONDARY_ACCOUNT_INDEX_START = 2, 1082}; 1083 1084static const TestAccountInfo kTestAccounts[] = { 1085 {"__dummy__@invalid.domain", "hashdummy", "Dummy Account"}, 1086 {"alice@invalid.domain", "hashalice", "Alice"}, 1087 {"bob@invalid.domain", "hashbob", "Bob"}, 1088 {"charlie@invalid.domain", "hashcharlie", "Charlie"}, 1089}; 1090 1091// Test fixture class for testing multi-profile features. 1092class MultiProfileFileManagerBrowserTest : public FileManagerBrowserTestBase { 1093 protected: 1094 // Enables multi-profiles. 1095 virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE { 1096 FileManagerBrowserTestBase::SetUpCommandLine(command_line); 1097 // Logs in to a dummy profile (For making MultiProfileWindowManager happy; 1098 // browser test creates a default window and the manager tries to assign a 1099 // user for it, and we need a profile connected to a user.) 1100 command_line->AppendSwitchASCII(chromeos::switches::kLoginUser, 1101 kTestAccounts[DUMMY_ACCOUNT_INDEX].email); 1102 command_line->AppendSwitchASCII(chromeos::switches::kLoginProfile, 1103 kTestAccounts[DUMMY_ACCOUNT_INDEX].hash); 1104 } 1105 1106 // Logs in to the primary profile of this test. 1107 virtual void SetUpOnMainThread() OVERRIDE { 1108 const TestAccountInfo& info = kTestAccounts[PRIMARY_ACCOUNT_INDEX]; 1109 1110 AddUser(info, true); 1111 FileManagerBrowserTestBase::SetUpOnMainThread(); 1112 } 1113 1114 // Loads all users to the current session and sets up necessary fields. 1115 // This is used for preparing all accounts in PRE_ test setup, and for testing 1116 // actual login behavior. 1117 void AddAllUsers() { 1118 for (size_t i = 0; i < arraysize(kTestAccounts); ++i) 1119 AddUser(kTestAccounts[i], i >= SECONDARY_ACCOUNT_INDEX_START); 1120 } 1121 1122 // Returns primary profile (if it is already created.) 1123 virtual Profile* profile() OVERRIDE { 1124 Profile* const profile = chromeos::ProfileHelper::GetProfileByUserIdHash( 1125 kTestAccounts[PRIMARY_ACCOUNT_INDEX].hash); 1126 return profile ? profile : FileManagerBrowserTestBase::profile(); 1127 } 1128 1129 // Sets the test case name (used as a function name in test_cases.js to call.) 1130 void set_test_case_name(const std::string& name) { test_case_name_ = name; } 1131 1132 // Adds a new user for testing to the current session. 1133 void AddUser(const TestAccountInfo& info, bool log_in) { 1134 user_manager::UserManager* const user_manager = 1135 user_manager::UserManager::Get(); 1136 if (log_in) 1137 user_manager->UserLoggedIn(info.email, info.hash, false); 1138 user_manager->SaveUserDisplayName(info.email, 1139 base::UTF8ToUTF16(info.display_name)); 1140 chromeos::ProfileHelper::GetProfileByUserIdHash(info.hash)->GetPrefs()-> 1141 SetString(prefs::kGoogleServicesUsername, info.email); 1142 } 1143 1144 private: 1145 virtual GuestMode GetGuestModeParam() const OVERRIDE { 1146 return NOT_IN_GUEST_MODE; 1147 } 1148 1149 virtual const char* GetTestCaseNameParam() const OVERRIDE { 1150 return test_case_name_.c_str(); 1151 } 1152 1153 virtual std::string OnMessage(const std::string& name, 1154 const base::Value* value) OVERRIDE { 1155 if (name == "addAllUsers") { 1156 AddAllUsers(); 1157 return "true"; 1158 } else if (name == "getWindowOwnerId") { 1159 chrome::MultiUserWindowManager* const window_manager = 1160 chrome::MultiUserWindowManager::GetInstance(); 1161 apps::AppWindowRegistry* const app_window_registry = 1162 apps::AppWindowRegistry::Get(profile()); 1163 DCHECK(window_manager); 1164 DCHECK(app_window_registry); 1165 1166 const apps::AppWindowRegistry::AppWindowList& list = 1167 app_window_registry->GetAppWindowsForApp( 1168 file_manager::kFileManagerAppId); 1169 return list.size() == 1u ? 1170 window_manager->GetUserPresentingWindow( 1171 list.front()->GetNativeWindow()) : ""; 1172 } 1173 return FileManagerBrowserTestBase::OnMessage(name, value); 1174 } 1175 1176 std::string test_case_name_; 1177}; 1178 1179// Slow tests are disabled on debug build. http://crbug.com/327719 1180#if !defined(NDEBUG) 1181#define MAYBE_PRE_BasicDownloads DISABLED_PRE_BasicDownloads 1182#define MAYBE_BasicDownloads DISABLED_BasicDownloads 1183#else 1184#define MAYBE_PRE_BasicDownloads PRE_BasicDownloads 1185#define MAYBE_BasicDownloads BasicDownloads 1186#endif 1187IN_PROC_BROWSER_TEST_F(MultiProfileFileManagerBrowserTest, 1188 MAYBE_PRE_BasicDownloads) { 1189 AddAllUsers(); 1190} 1191 1192IN_PROC_BROWSER_TEST_F(MultiProfileFileManagerBrowserTest, 1193 MAYBE_BasicDownloads) { 1194 AddAllUsers(); 1195 1196 // Sanity check that normal operations work in multi-profile setting as well. 1197 set_test_case_name("keyboardCopyDownloads"); 1198 StartTest(); 1199} 1200 1201// Slow tests are disabled on debug build. http://crbug.com/327719 1202#if !defined(NDEBUG) 1203#define MAYBE_PRE_BasicDrive DISABLED_PRE_BasicDrive 1204#define MAYBE_BasicDrive DISABLED_BasicDrive 1205#else 1206#define MAYBE_PRE_BasicDrive PRE_BasicDrive 1207#define MAYBE_BasicDrive BasicDrive 1208#endif 1209IN_PROC_BROWSER_TEST_F(MultiProfileFileManagerBrowserTest, 1210 MAYBE_PRE_BasicDrive) { 1211 AddAllUsers(); 1212} 1213 1214IN_PROC_BROWSER_TEST_F(MultiProfileFileManagerBrowserTest, MAYBE_BasicDrive) { 1215 AddAllUsers(); 1216 1217 // Sanity check that normal operations work in multi-profile setting as well. 1218 set_test_case_name("keyboardCopyDrive"); 1219 StartTest(); 1220} 1221 1222// Slow tests are disabled on debug build. http://crbug.com/327719 1223#if !defined(NDEBUG) 1224#define MAYBE_PRE_Badge DISABLED_PRE_Badge 1225#define MAYBE_Badge DISABLED_Badge 1226#else 1227#define MAYBE_PRE_Badge PRE_Badge 1228#define MAYBE_Badge Badge 1229#endif 1230IN_PROC_BROWSER_TEST_F(MultiProfileFileManagerBrowserTest, MAYBE_PRE_Badge) { 1231 AddAllUsers(); 1232} 1233 1234IN_PROC_BROWSER_TEST_F(MultiProfileFileManagerBrowserTest, MAYBE_Badge) { 1235 // Test the profile badge to be correctly shown and hidden. 1236 set_test_case_name("multiProfileBadge"); 1237 StartTest(); 1238} 1239 1240// Slow tests are disabled on debug build. http://crbug.com/327719 1241#if !defined(NDEBUG) 1242#define MAYBE_PRE_VisitDesktopMenu DISABLED_PRE_VisitDesktopMenu 1243#define MAYBE_VisitDesktopMenu DISABLED_VisitDesktopMenu 1244#else 1245#define MAYBE_PRE_VisitDesktopMenu PRE_VisitDesktopMenu 1246#define MAYBE_VisitDesktopMenu VisitDesktopMenu 1247#endif 1248IN_PROC_BROWSER_TEST_F(MultiProfileFileManagerBrowserTest, 1249 MAYBE_PRE_VisitDesktopMenu) { 1250 AddAllUsers(); 1251} 1252 1253IN_PROC_BROWSER_TEST_F(MultiProfileFileManagerBrowserTest, 1254 MAYBE_VisitDesktopMenu) { 1255 // Test for the menu item for visiting other profile's desktop. 1256 set_test_case_name("multiProfileVisitDesktopMenu"); 1257 StartTest(); 1258} 1259 1260template<GuestMode M> 1261class GalleryBrowserTestBase : public FileManagerBrowserTestBase { 1262 public: 1263 virtual GuestMode GetGuestModeParam() const OVERRIDE { return M; } 1264 virtual const char* GetTestCaseNameParam() const OVERRIDE { 1265 return test_case_name_.c_str(); 1266 } 1267 1268 protected: 1269 virtual void SetUp() OVERRIDE { 1270 AddScript("common/test_util_common.js"); 1271 AddScript("gallery/test_util.js"); 1272 FileManagerBrowserTestBase::SetUp(); 1273 } 1274 1275 virtual std::string OnMessage(const std::string& name, 1276 const base::Value* value) OVERRIDE; 1277 1278 virtual const char* GetTestManifestName() const OVERRIDE { 1279 return "gallery_test_manifest.json"; 1280 } 1281 1282 void AddScript(const std::string& name) { 1283 scripts_.AppendString( 1284 "chrome-extension://ejhcmmdhhpdhhgmifplfmjobgegbibkn/" + name); 1285 } 1286 1287 void set_test_case_name(const std::string& name) { 1288 test_case_name_ = name; 1289 } 1290 1291 private: 1292 base::ListValue scripts_; 1293 std::string test_case_name_; 1294}; 1295 1296template<GuestMode M> 1297std::string GalleryBrowserTestBase<M>::OnMessage(const std::string& name, 1298 const base::Value* value) { 1299 if (name == "getScripts") { 1300 std::string jsonString; 1301 base::JSONWriter::Write(&scripts_, &jsonString); 1302 return jsonString; 1303 } 1304 return FileManagerBrowserTestBase::OnMessage(name, value); 1305} 1306 1307typedef GalleryBrowserTestBase<NOT_IN_GUEST_MODE> GalleryBrowserTest; 1308typedef GalleryBrowserTestBase<IN_GUEST_MODE> GalleryBrowserTestInGuestMode; 1309 1310IN_PROC_BROWSER_TEST_F(GalleryBrowserTest, OpenSingleImageOnDownloads) { 1311 AddScript("gallery/open_image_files.js"); 1312 set_test_case_name("openSingleImageOnDownloads"); 1313 StartTest(); 1314} 1315 1316IN_PROC_BROWSER_TEST_F(GalleryBrowserTestInGuestMode, 1317 OpenSingleImageOnDownloads) { 1318 AddScript("gallery/open_image_files.js"); 1319 set_test_case_name("openSingleImageOnDownloads"); 1320 StartTest(); 1321} 1322 1323IN_PROC_BROWSER_TEST_F(GalleryBrowserTest, OpenSingleImageOnDrive) { 1324 AddScript("gallery/open_image_files.js"); 1325 set_test_case_name("openSingleImageOnDrive"); 1326 StartTest(); 1327} 1328 1329IN_PROC_BROWSER_TEST_F(GalleryBrowserTest, OpenMultipleImagesOnDownloads) { 1330 AddScript("gallery/open_image_files.js"); 1331 set_test_case_name("openMultipleImagesOnDownloads"); 1332 StartTest(); 1333} 1334 1335IN_PROC_BROWSER_TEST_F(GalleryBrowserTestInGuestMode, 1336 OpenMultipleImagesOnDownloads) { 1337 AddScript("gallery/open_image_files.js"); 1338 set_test_case_name("openMultipleImagesOnDownloads"); 1339 StartTest(); 1340} 1341 1342IN_PROC_BROWSER_TEST_F(GalleryBrowserTest, OpenMultipleImagesOnDrive) { 1343 AddScript("gallery/open_image_files.js"); 1344 set_test_case_name("openMultipleImagesOnDrive"); 1345 StartTest(); 1346} 1347 1348IN_PROC_BROWSER_TEST_F(GalleryBrowserTest, TraverseSlideImagesOnDownloads) { 1349 AddScript("gallery/slide_mode.js"); 1350 set_test_case_name("traverseSlideImagesOnDownloads"); 1351 StartTest(); 1352} 1353 1354IN_PROC_BROWSER_TEST_F(GalleryBrowserTestInGuestMode, 1355 TraverseSlideImagesOnDownloads) { 1356 AddScript("gallery/slide_mode.js"); 1357 set_test_case_name("traverseSlideImagesOnDownloads"); 1358 StartTest(); 1359} 1360 1361IN_PROC_BROWSER_TEST_F(GalleryBrowserTest, TraverseSlideImagesOnDrive) { 1362 AddScript("gallery/slide_mode.js"); 1363 set_test_case_name("traverseSlideImagesOnDrive"); 1364 StartTest(); 1365} 1366 1367IN_PROC_BROWSER_TEST_F(GalleryBrowserTest, RenameImageOnDownloads) { 1368 AddScript("gallery/slide_mode.js"); 1369 set_test_case_name("renameImageOnDownloads"); 1370 StartTest(); 1371} 1372 1373IN_PROC_BROWSER_TEST_F(GalleryBrowserTestInGuestMode, 1374 RenameImageOnDownloads) { 1375 AddScript("gallery/slide_mode.js"); 1376 set_test_case_name("renameImageOnDownloads"); 1377 StartTest(); 1378} 1379 1380IN_PROC_BROWSER_TEST_F(GalleryBrowserTest, RenameImageOnDrive) { 1381 AddScript("gallery/slide_mode.js"); 1382 set_test_case_name("renameImageOnDrive"); 1383 StartTest(); 1384} 1385 1386IN_PROC_BROWSER_TEST_F(GalleryBrowserTest, DeleteImageOnDownloads) { 1387 AddScript("gallery/slide_mode.js"); 1388 set_test_case_name("deleteImageOnDownloads"); 1389 StartTest(); 1390} 1391 1392IN_PROC_BROWSER_TEST_F(GalleryBrowserTestInGuestMode, 1393 DeleteImageOnDownloads) { 1394 AddScript("gallery/slide_mode.js"); 1395 set_test_case_name("deleteImageOnDownloads"); 1396 StartTest(); 1397} 1398 1399IN_PROC_BROWSER_TEST_F(GalleryBrowserTest, DeleteImageOnDrive) { 1400 AddScript("gallery/slide_mode.js"); 1401 set_test_case_name("deleteImageOnDrive"); 1402 StartTest(); 1403} 1404 1405IN_PROC_BROWSER_TEST_F(GalleryBrowserTest, RotateImageOnDownloads) { 1406 AddScript("gallery/photo_editor.js"); 1407 set_test_case_name("rotateImageOnDownloads"); 1408 StartTest(); 1409} 1410 1411IN_PROC_BROWSER_TEST_F(GalleryBrowserTestInGuestMode, 1412 RotateImageOnDownloads) { 1413 AddScript("gallery/photo_editor.js"); 1414 set_test_case_name("rotateImageOnDownloads"); 1415 StartTest(); 1416} 1417 1418IN_PROC_BROWSER_TEST_F(GalleryBrowserTest, RotateImageOnDrive) { 1419 AddScript("gallery/photo_editor.js"); 1420 set_test_case_name("rotateImageOnDrive"); 1421 StartTest(); 1422} 1423 1424IN_PROC_BROWSER_TEST_F(GalleryBrowserTest, CropImageOnDownloads) { 1425 AddScript("gallery/photo_editor.js"); 1426 set_test_case_name("cropImageOnDownloads"); 1427 StartTest(); 1428} 1429 1430IN_PROC_BROWSER_TEST_F(GalleryBrowserTestInGuestMode, 1431 CropImageOnDownloads) { 1432 AddScript("gallery/photo_editor.js"); 1433 set_test_case_name("cropImageOnDownloads"); 1434 StartTest(); 1435} 1436 1437IN_PROC_BROWSER_TEST_F(GalleryBrowserTest, CropImageOnDrive) { 1438 AddScript("gallery/photo_editor.js"); 1439 set_test_case_name("cropImageOnDrive"); 1440 StartTest(); 1441} 1442 1443IN_PROC_BROWSER_TEST_F(GalleryBrowserTest, ExposureImageOnDownloads) { 1444 AddScript("gallery/photo_editor.js"); 1445 set_test_case_name("exposureImageOnDownloads"); 1446 StartTest(); 1447} 1448 1449IN_PROC_BROWSER_TEST_F(GalleryBrowserTestInGuestMode, 1450 ExposureImageOnDownloads) { 1451 AddScript("gallery/photo_editor.js"); 1452 set_test_case_name("exposureImageOnDownloads"); 1453 StartTest(); 1454} 1455 1456IN_PROC_BROWSER_TEST_F(GalleryBrowserTest, ExposureImageOnDrive) { 1457 AddScript("gallery/photo_editor.js"); 1458 set_test_case_name("exposureImageOnDrive"); 1459 StartTest(); 1460} 1461 1462template<GuestMode M> 1463class VideoPlayerBrowserTestBase : public FileManagerBrowserTestBase { 1464 public: 1465 virtual GuestMode GetGuestModeParam() const OVERRIDE { return M; } 1466 virtual const char* GetTestCaseNameParam() const OVERRIDE { 1467 return test_case_name_.c_str(); 1468 } 1469 1470 protected: 1471 virtual void SetUp() OVERRIDE { 1472 AddScript("common/test_util_common.js"); 1473 AddScript("video_player/test_util.js"); 1474 FileManagerBrowserTestBase::SetUp(); 1475 } 1476 1477 virtual std::string OnMessage(const std::string& name, 1478 const base::Value* value) OVERRIDE; 1479 1480 virtual const char* GetTestManifestName() const OVERRIDE { 1481 return "video_player_test_manifest.json"; 1482 } 1483 1484 void AddScript(const std::string& name) { 1485 scripts_.AppendString( 1486 "chrome-extension://ljoplibgfehghmibaoaepfagnmbbfiga/" + name); 1487 } 1488 1489 void set_test_case_name(const std::string& name) { 1490 test_case_name_ = name; 1491 } 1492 1493 private: 1494 base::ListValue scripts_; 1495 std::string test_case_name_; 1496}; 1497 1498template<GuestMode M> 1499std::string VideoPlayerBrowserTestBase<M>::OnMessage(const std::string& name, 1500 const base::Value* value) { 1501 if (name == "getScripts") { 1502 std::string jsonString; 1503 base::JSONWriter::Write(&scripts_, &jsonString); 1504 return jsonString; 1505 } 1506 return FileManagerBrowserTestBase::OnMessage(name, value); 1507} 1508 1509typedef VideoPlayerBrowserTestBase<NOT_IN_GUEST_MODE> VideoPlayerBrowserTest; 1510typedef VideoPlayerBrowserTestBase<IN_GUEST_MODE> 1511 VideoPlayerBrowserTestInGuestMode; 1512 1513IN_PROC_BROWSER_TEST_F(VideoPlayerBrowserTest, OpenSingleVideoOnDownloads) { 1514 AddScript("video_player/open_video_files.js"); 1515 set_test_case_name("openSingleVideoOnDownloads"); 1516 StartTest(); 1517} 1518 1519IN_PROC_BROWSER_TEST_F(VideoPlayerBrowserTest, OpenSingleVideoOnDrive) { 1520 AddScript("video_player/open_video_files.js"); 1521 set_test_case_name("openSingleVideoOnDrive"); 1522 StartTest(); 1523} 1524 1525} // namespace 1526} // namespace file_manager 1527