Files.app: Refactoring for the onMessage function of FIleManagerBrowserTest.

chrome/browser/chromeos/file_manager/file_manager_browsertest.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Browser test for basic Chrome OS file manager functionality:
 //  - The file list is updated when a file is added externally to the Downloads
 //    folder.
 //  - Selecting a file and copy-pasting it with the keyboard copies the file.
 //  - Selecting a file and pressing delete deletes it.
 
@@ skipping 527 matching lines @@
   // test.
   virtual void StartTest();
   void RunTestMessageLoop();
 
   // Overriding point for test configurations.
   virtual const char* GetTestManifestName() const {
     return "file_manager_test_manifest.json";
   }
   virtual GuestMode GetGuestModeParam() const = 0;
   virtual const char* GetTestCaseNameParam() const = 0;
-  virtual std::string OnMessage(const std::string& name,
-                                const base::Value* value);
+  virtual void OnMessage(const std::string& name,
+                         const base::Value& value,
+                         std::string* output);
 
   scoped_ptr<LocalTestVolume> local_volume_;
   linked_ptr<DriveTestVolume> drive_volume_;
   std::map<Profile*, linked_ptr<DriveTestVolume> > drive_volumes_;
   scoped_ptr<FakeTestVolume> usb_volume_;
   scoped_ptr<FakeTestVolume> mtp_volume_;
 
  private:
   drive::DriveIntegrationService* CreateDriveIntegrationService(
       Profile* profile);
@@ skipping 75 matching lines @@
     const scoped_ptr<const base::Value> value(
         base::JSONReader::Read(entry.message));
 
     // If the message is not the expected format, just ignore it.
     const base::DictionaryValue* message_dictionary = NULL;
     std::string name;
     if (!value || !value->GetAsDictionary(&message_dictionary) ||
         !message_dictionary->GetString("name", &name))
       continue;
 
-    entry.function->Reply(OnMessage(name, value.get()));
+    std::string output;
+    OnMessage(name, *value.get(), &output);
+    if (HasFatalFailure())
+      break;
+    entry.function->Reply(output);
   }
 }
 
-std::string FileManagerBrowserTestBase::OnMessage(const std::string& name,
-                                                  const base::Value* value) {
+void FileManagerBrowserTestBase::OnMessage(const std::string& name,
+                                           const base::Value& value,
+                                           std::string* output) {
   if (name == "getTestName") {
     // Pass the test case name.
-    return GetTestCaseNameParam();
-  } else if (name == "getRootPaths") {
+    *output = GetTestCaseNameParam();
+    return;
+  }
+
+  if (name == "getRootPaths") {
     // Pass the root paths.
     const scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue());
     res->SetString("downloads",
         "/" + util::GetDownloadsMountPointName(profile()));
     res->SetString("drive",
         "/" + drive::util::GetDriveMountPointPath(profile()
             ).BaseName().AsUTF8Unsafe() + "/root");
-    std::string jsonString;
-    base::JSONWriter::Write(res.get(), &jsonString);
-    return jsonString;
-  } else if (name == "isInGuestMode") {
+    base::JSONWriter::Write(res.get(), output);
+    return;
+  }
+
+  if (name == "isInGuestMode") {
     // Obtain whether the test is in guest mode or not.
-    return GetGuestModeParam() != NOT_IN_GUEST_MODE ? "true" : "false";
-  } else if (name == "getCwsWidgetContainerMockUrl") {
+    *output = GetGuestModeParam() != NOT_IN_GUEST_MODE ? "true" : "false";
+    return;
+  }
+
+  if (name == "getCwsWidgetContainerMockUrl") {
     // Obtain whether the test is in guest mode or not.
     const GURL url = embedded_test_server()->GetURL(
           "/chromeos/file_manager/cws_container_mock/index.html");
     std::string origin = url.GetOrigin().spec();
 
     // Removes trailing a slash.
     if (*origin.rbegin() == '/')
       origin.resize(origin.length() - 1);
 
     const scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue());
     res->SetString("url", url.spec());
     res->SetString("origin", origin);
-    std::string jsonString;
-    base::JSONWriter::Write(res.get(), &jsonString);
-    return jsonString;
-  } else if (name == "addEntries") {
+    base::JSONWriter::Write(res.get(), output);
+    return;
+  }
+
+  if (name == "addEntries") {
     // Add entries to the specified volume.
     base::JSONValueConverter<AddEntriesMessage> add_entries_message_converter;
     AddEntriesMessage message;
-    if (!add_entries_message_converter.Convert(*value, &message))
-      return "onError";
+    ASSERT_TRUE(add_entries_message_converter.Convert(value, &message));
+
     for (size_t i = 0; i < message.entries.size(); ++i) {
       switch (message.volume) {
         case LOCAL_VOLUME:
           local_volume_->CreateEntry(*message.entries[i]);
           break;
         case DRIVE_VOLUME:
           if (drive_volume_.get())
             drive_volume_->CreateEntry(*message.entries[i]);
           break;
         case USB_VOLUME:
           if (usb_volume_)
             usb_volume_->CreateEntry(*message.entries[i]);
           break;
         default:
           NOTREACHED();
           break;
       }
     }
-    return "onEntryAdded";
-  } else if (name == "mountFakeUsb") {
+
+    return;
+  }
+
+  if (name == "mountFakeUsb") {
     usb_volume_.reset(new FakeTestVolume("fake-usb",
                                          VOLUME_TYPE_REMOVABLE_DISK_PARTITION,
                                          chromeos::DEVICE_TYPE_USB));
     usb_volume_->Mount(profile());
-    return "true";
-  } else if (name == "mountFakeMtp") {
+    return;
+  }
+
+  if (name == "mountFakeMtp") {
     mtp_volume_.reset(new FakeTestVolume("fake-mtp",
                                          VOLUME_TYPE_MTP,
                                          chromeos::DEVICE_TYPE_UNKNOWN));
-    if (!mtp_volume_->PrepareTestEntries(profile()))
-      return "false";
+    ASSERT_TRUE(mtp_volume_->PrepareTestEntries(profile()));
+
     mtp_volume_->Mount(profile());
-    return "true";
+    return;
   }
-  return "unknownMessage";
+
+  FAIL() << "Unknown test message: " << name;
 }
 
 drive::DriveIntegrationService*
 FileManagerBrowserTestBase::CreateDriveIntegrationService(Profile* profile) {
   drive_volumes_[profile->GetOriginalProfile()].reset(new DriveTestVolume());
   return drive_volumes_[profile->GetOriginalProfile()]->
       CreateDriveIntegrationService(profile);
 }
 
 // Parameter of FileManagerBrowserTest.
@@ skipping 403 matching lines @@
 
  private:
   virtual GuestMode GetGuestModeParam() const override {
     return NOT_IN_GUEST_MODE;
   }
 
   virtual const char* GetTestCaseNameParam() const override {
     return test_case_name_.c_str();
   }
 
-  virtual std::string OnMessage(const std::string& name,
-                                const base::Value* value) override {
-    if (name == "addAllUsers") {
-      AddAllUsers();
-      return "true";
-    } else if (name == "getWindowOwnerId") {
-      chrome::MultiUserWindowManager* const window_manager =
-          chrome::MultiUserWindowManager::GetInstance();
-      extensions::AppWindowRegistry* const app_window_registry =
-          extensions::AppWindowRegistry::Get(profile());
-      DCHECK(window_manager);
-      DCHECK(app_window_registry);
-
-      const extensions::AppWindowRegistry::AppWindowList& list =
-          app_window_registry->GetAppWindowsForApp(
-              file_manager::kFileManagerAppId);
-      return list.size() == 1u ?
-          window_manager->GetUserPresentingWindow(
-              list.front()->GetNativeWindow()) : "";
-    }
-    return FileManagerBrowserTestBase::OnMessage(name, value);
-  }
-
   std::string test_case_name_;
 };
 
 // Slow tests are disabled on debug build. http://crbug.com/327719
 #if !defined(NDEBUG)
 #define MAYBE_PRE_BasicDownloads DISABLED_PRE_BasicDownloads
 #define MAYBE_BasicDownloads DISABLED_BasicDownloads
 #else
 #define MAYBE_PRE_BasicDownloads PRE_BasicDownloads
 #define MAYBE_BasicDownloads BasicDownloads
@@ skipping 41 matching lines @@
     return test_case_name_.c_str();
   }
 
  protected:
   virtual void SetUp() override {
     AddScript("common/test_util_common.js");
     AddScript("gallery/test_util.js");
     FileManagerBrowserTestBase::SetUp();
   }
 
-  virtual std::string OnMessage(const std::string& name,
-                                const base::Value* value) override;
+  virtual void OnMessage(const std::string& name,
+                         const base::Value& value,
+                         std::string* output) override;
 
   virtual const char* GetTestManifestName() const override {
     return "gallery_test_manifest.json";
   }
 
   void AddScript(const std::string& name) {
     scripts_.AppendString(
         "chrome-extension://ejhcmmdhhpdhhgmifplfmjobgegbibkn/" + name);
   }
 
   void set_test_case_name(const std::string& name) {
     test_case_name_ = name;
   }
 
  private:
   base::ListValue scripts_;
   std::string test_case_name_;
 };
 
-template<GuestMode M>
-std::string GalleryBrowserTestBase<M>::OnMessage(const std::string& name,
-                                                 const base::Value* value) {
+template <GuestMode M>
+void GalleryBrowserTestBase<M>::OnMessage(const std::string& name,
+                                          const base::Value& value,
+                                          std::string* output) {
   if (name == "getScripts") {
     std::string jsonString;
-    base::JSONWriter::Write(&scripts_, &jsonString);
-    return jsonString;
+    base::JSONWriter::Write(&scripts_, output);
+    return;
   }
-  return FileManagerBrowserTestBase::OnMessage(name, value);
+
+  FileManagerBrowserTestBase::OnMessage(name, value, output);
 }
 
 typedef GalleryBrowserTestBase<NOT_IN_GUEST_MODE> GalleryBrowserTest;
 typedef GalleryBrowserTestBase<IN_GUEST_MODE> GalleryBrowserTestInGuestMode;
 
 IN_PROC_BROWSER_TEST_F(GalleryBrowserTest, OpenSingleImageOnDownloads) {
   AddScript("gallery/open_image_files.js");
   set_test_case_name("openSingleImageOnDownloads");
   StartTest();
 }
@@ skipping 158 matching lines @@
     AddScript("video_player/test_util.js");
     FileManagerBrowserTestBase::SetUp();
   }
 
   virtual void SetUpCommandLine(CommandLine* command_line) override {
     command_line->AppendSwitch(
         chromeos::switches::kEnableVideoPlayerChromecastSupport);
     FileManagerBrowserTestBase::SetUpCommandLine(command_line);
   }
 
-  virtual std::string OnMessage(const std::string& name,
-                                const base::Value* value) override;
+  virtual void OnMessage(const std::string& name,
+                         const base::Value& value,
+                         std::string* output) override;
 
   virtual const char* GetTestManifestName() const override {
     return "video_player_test_manifest.json";
   }
 
   void AddScript(const std::string& name) {
     scripts_.AppendString(
         "chrome-extension://ljoplibgfehghmibaoaepfagnmbbfiga/" + name);
   }
 
   void set_test_case_name(const std::string& name) {
     test_case_name_ = name;
   }
 
  private:
   base::ListValue scripts_;
   std::string test_case_name_;
 };
 
-template<GuestMode M>
-std::string VideoPlayerBrowserTestBase<M>::OnMessage(const std::string& name,
-                                                     const base::Value* value) {
+template <GuestMode M>
+void VideoPlayerBrowserTestBase<M>::OnMessage(const std::string& name,
+                                              const base::Value& value,
+                                              std::string* output) {
   if (name == "getScripts") {
     std::string jsonString;
-    base::JSONWriter::Write(&scripts_, &jsonString);
-    return jsonString;
+    base::JSONWriter::Write(&scripts_, output);
+    return;
   }
-  return FileManagerBrowserTestBase::OnMessage(name, value);
+
+  FileManagerBrowserTestBase::OnMessage(name, value, output);
 }
 
 typedef VideoPlayerBrowserTestBase<NOT_IN_GUEST_MODE> VideoPlayerBrowserTest;
 typedef VideoPlayerBrowserTestBase<IN_GUEST_MODE>
     VideoPlayerBrowserTestInGuestMode;
 
 IN_PROC_BROWSER_TEST_F(VideoPlayerBrowserTest, OpenSingleVideoOnDownloads) {
   AddScript("video_player/open_video_files.js");
   set_test_case_name("openSingleVideoOnDownloads");
   StartTest();
 }
 
 IN_PROC_BROWSER_TEST_F(VideoPlayerBrowserTest, OpenSingleVideoOnDrive) {
   AddScript("video_player/open_video_files.js");
   set_test_case_name("openSingleVideoOnDrive");
   StartTest();
 }
 
 }  // namespace
 }  // namespace file_manager