Implement browser test for It2Me

chrome/test/remoting/remote_desktop_browsertest.cc

 // Copyright 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.
 
 #include "chrome/test/remoting/remote_desktop_browsertest.h"
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/path_service.h"
@@ skipping 148 matching lines @@
     extensions::Manifest::Type type = extension_->GetType();
     EXPECT_TRUE(type == extensions::Manifest::TYPE_PLATFORM_APP ||
                 type == extensions::Manifest::TYPE_LEGACY_PACKAGED_APP);
 
     EXPECT_TRUE(extension_->ShouldDisplayInAppLauncher());
   }
 
   ASSERT_EQ(installed, expected);
 }
 
-void RemoteDesktopBrowserTest::LaunchChromotingApp(bool defer_start) {
+void RemoteDesktopBrowserTest::LaunchChromotingApp(
+    bool defer_start,
+    WindowOpenDisposition opt_window_open_disposition) {
   ASSERT_TRUE(extension_);
 
   GURL chromoting_main = Chromoting_Main_URL();
   // We cannot simply wait for any page load because the first page
   // loaded could be the generated background page. We need to wait
   // till the chromoting main page is loaded.
   PageLoadNotificationObserver observer(chromoting_main);
   observer.set_ignore_url_parameters(true);
 
   // If the app should be started in deferred mode, ensure that a "source" URL
   // parameter; if not, ensure that no such parameter is present. The value of
   // the parameter is determined by the AppLaunchParams ("test", in this case).
   extensions::FeatureSwitch::ScopedOverride override_trace_app_source(
       extensions::FeatureSwitch::trace_app_source(),
       defer_start);
 
   OpenApplication(AppLaunchParams(browser()->profile(), extension_,
                                   is_platform_app()
                                       ? extensions::LAUNCH_CONTAINER_NONE
                                       : extensions::LAUNCH_CONTAINER_TAB,
-                                  is_platform_app() ? NEW_WINDOW : CURRENT_TAB,
+                                  opt_window_open_disposition,
                                   extensions::SOURCE_TEST));
 
   observer.Wait();
 
 
   // The active WebContents instance should be the source of the LOAD_STOP
   // notification.
   content::NavigationController* controller =
       content::Source<content::NavigationController>(observer.source()).ptr();
 
@@ skipping 10 matching lines @@
     // event. A half second wait is necessary for the subsequent javascript
     // injection to work.
     // TODO(weitaosu): Find out whether there is a more appropriate notification
     // to wait for so we can get rid of this wait.
     ASSERT_TRUE(TimeoutWaiter(base::TimeDelta::FromSeconds(5)).Wait());
   }
 
   EXPECT_EQ(Chromoting_Main_URL(), GetCurrentURL());
 }
 
+void RemoteDesktopBrowserTest::LaunchChromotingApp(bool defer_start) {
+  LaunchChromotingApp(defer_start,
+                      is_platform_app() ? NEW_WINDOW : CURRENT_TAB);
+}
+
 void RemoteDesktopBrowserTest::StartChromotingApp() {
   ClickOnControl("browser-test-continue-init");
 };
 
 void RemoteDesktopBrowserTest::Authorize() {
   // The chromoting extension should be installed.
   ASSERT_TRUE(extension_);
 
   // The chromoting main page should be loaded in the current tab
   // and isAuthenticated() should be false (auth dialog visible).
@@ skipping 479 matching lines @@
   base::FilePath script_path = src_dir.Append(path);
 
   if (!base::ReadFileToString(script_path, &script)) {
     LOG(ERROR) << "Failed to load script " << script_path.value();
     return false;
   }
 
   return content::ExecuteScript(web_contents, script);
 }
 
-// static
 void RemoteDesktopBrowserTest::RunJavaScriptTest(
     content::WebContents* web_contents,
     const std::string& testName,
-    const std::string& testData) {
+    const std::string& testData,
+    base::Value** opt_return_value) {
   std::string result;
   std::string script = "browserTest.runTest(browserTest." + testName + ", " +
                        testData + ");";
 
   DVLOG(1) << "Executing " << script;
 
   ASSERT_TRUE(
       content::ExecuteScriptAndExtractString(web_contents, script, &result));
 
   // Read in the JSON
   base::JSONReader reader;
   scoped_ptr<base::Value> value;
   value.reset(reader.Read(result, base::JSON_ALLOW_TRAILING_COMMAS));
 
   // Convert to dictionary
-  base::DictionaryValue* dict_value = NULL;
+  base::DictionaryValue* dict_value = nullptr;
   ASSERT_TRUE(value->GetAsDictionary(&dict_value));
 
   bool succeeded;
   std::string error_message;
   std::string stack_trace;
 
   // Extract the fields
   ASSERT_TRUE(dict_value->GetBoolean("succeeded", &succeeded));
   ASSERT_TRUE(dict_value->GetString("error_message", &error_message));
   ASSERT_TRUE(dict_value->GetString("stack_trace", &stack_trace));
 
   EXPECT_TRUE(succeeded) << error_message << "\n" << stack_trace;
+
+  base::Value* return_value = nullptr;
+  if (dict_value->Get("value", &return_value) && return_value != nullptr) {
+    ASSERT_EQ(*opt_return_value, nullptr);
+    *opt_return_value = return_value->DeepCopy();
+  }
 }
 
+void RemoteDesktopBrowserTest::RunJavaScriptTest(
+    content::WebContents* web_contents,
+    const std::string& testName,
+    const std::string& testData) {
+  base::Value* return_value = nullptr;
+  RunJavaScriptTest(web_contents, testName, testData, &return_value);
+  if (return_value != nullptr) {
+    delete return_value;

[Jamie, 2015/01/06 22:18:51]

No need to test for null before deleting. Better still, can you use a scoped_ptr
to do the delete for you?

[kelvinp, 2015/01/09 22:21:30]

Done.

+  }
+};
+
+
 void RemoteDesktopBrowserTest::ClickOnControl(const std::string& name) {
   ASSERT_TRUE(HtmlElementVisible(name));
 
   std::string has_disabled_attribute =
     "document.getElementById('" + name + "').hasAttribute('disabled')";
 
   if (ExecuteScriptAndExtractBool(active_web_contents(),
                                   has_disabled_attribute)) {
     // This element has a disabled attribute. Wait for it become enabled.
     ConditionalTimeoutWaiter waiter(
@@ skipping 130 matching lines @@
 // static
 bool RemoteDesktopBrowserTest::IsEnabled(
     content::WebContents* client_web_content,
     const std::string& element_name) {
   return !ExecuteScriptAndExtractBool(
     client_web_content,
     "document.getElementById(\"" + element_name + "\").disabled");
 }
 
 }  // namespace remoting