Logging API in chromedriver2.

chrome/test/chromedriver/chrome_launcher.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.
 
 #include "chrome/test/chromedriver/chrome_launcher.h"
 
 #include "base/base64.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
@@ skipping 159 matching lines @@
     client->GetWebViewsInfo(&views_info);
     if (views_info.GetSize()) {
       *user_client = client.Pass();
       return Status(kOk);
     }
     base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(100));
   }
   return Status(kUnknownError, "unable to discover open pages");
 }
 
-Status LaunchDesktopChrome(URLRequestContextGetter* context_getter,
-                           int port,
-                           const SyncWebSocketFactory& socket_factory,
-                           const Capabilities& capabilities,
-                           scoped_ptr<Chrome>* chrome) {
+Status LaunchDesktopChrome(
+    URLRequestContextGetter* context_getter,
+    int port,
+    const SyncWebSocketFactory& socket_factory,
+    const Capabilities& capabilities,
+    const std::list<DevToolsEventLogger*>& devtools_event_loggers,
+    scoped_ptr<Chrome>* chrome) {
   CommandLine command(CommandLine::NO_PROGRAM);
   base::ScopedTempDir user_data_dir;
   base::ScopedTempDir extension_dir;
   PrepareCommandLine(port, capabilities,
                      &command, &user_data_dir, &extension_dir);
   base::LaunchOptions options;
 
 #if !defined(OS_WIN)
   base::EnvironmentVector environ;
   if (!capabilities.log_path.empty()) {
@@ skipping 43 matching lines @@
     }
     if (!base::KillProcess(process, 0, true)) {
       int exit_code;
       if (base::GetTerminationStatus(process, &exit_code) ==
           base::TERMINATION_STATUS_STILL_RUNNING)
         return Status(kUnknownError, "cannot kill Chrome", status);
     }
     return status;
   }
   chrome->reset(new ChromeDesktopImpl(
-      devtools_client.Pass(), version, build_no, process, &user_data_dir,
-      &extension_dir));
+      devtools_client.Pass(), version, build_no, devtools_event_loggers,
+      process, &user_data_dir, &extension_dir));
   return Status(kOk);
 }
 
-Status LaunchAndroidChrome(URLRequestContextGetter* context_getter,
-                           int port,
-                           const SyncWebSocketFactory& socket_factory,
-                           const Capabilities& capabilities,
-                           scoped_ptr<Chrome>* chrome) {
+Status LaunchAndroidChrome(
+    URLRequestContextGetter* context_getter,
+    int port,
+    const SyncWebSocketFactory& socket_factory,
+    const Capabilities& capabilities,
+    const std::list<DevToolsEventLogger*>& devtools_event_loggers,
+    scoped_ptr<Chrome>* chrome) {
   // TODO(frankf): Figure out how this should be installed to
   // make this work for all platforms.
   base::FilePath adb_commands(FILE_PATH_LITERAL("adb_commands.py"));
   CommandLine command(adb_commands);
   command.AppendSwitchASCII("package", capabilities.android_package);
   command.AppendSwitch("launch");
   command.AppendSwitchASCII("port", base::IntToString(port));
 
   std::string output;
   if (!base::GetAppOutput(command, &output)) {
     if (output.empty())
       return Status(
           kUnknownError,
           "failed to run adb_commands.py. Make sure it is set in PATH.");
     else
       return Status(kUnknownError, "android app failed to start.\n" + output);
   }
 
   scoped_ptr<DevToolsHttpClient> devtools_client;
   std::string version;
   int build_no;
   Status status = WaitForDevToolsAndCheckVersion(
       port, context_getter, socket_factory, &devtools_client, &version,
       &build_no);
   if (status.IsError())
     return status;
 
   chrome->reset(new ChromeAndroidImpl(
-      devtools_client.Pass(), version, build_no));
+      devtools_client.Pass(), version, build_no, devtools_event_loggers));
   return Status(kOk);
 }
 
 }  // namespace
 
-Status LaunchChrome(URLRequestContextGetter* context_getter,
-                    int port,
-                    const SyncWebSocketFactory& socket_factory,
-                    const Capabilities& capabilities,
-                    scoped_ptr<Chrome>* chrome) {
+Status LaunchChrome(
+    URLRequestContextGetter* context_getter,
+    int port,
+    const SyncWebSocketFactory& socket_factory,
+    const Capabilities& capabilities,
+    const std::list<DevToolsEventLogger*>& devtools_event_loggers,
+    scoped_ptr<Chrome>* chrome) {
   if (capabilities.IsAndroid()) {
     return LaunchAndroidChrome(
-        context_getter, port, socket_factory, capabilities, chrome);
+        context_getter, port, socket_factory, capabilities,
+        devtools_event_loggers, chrome);
   } else {
     return LaunchDesktopChrome(
-        context_getter, port, socket_factory, capabilities, chrome);
+        context_getter, port, socket_factory, capabilities,
+        devtools_event_loggers, chrome);
   }
 }
 
 namespace internal {
 
 Status ProcessExtensions(const std::vector<std::string>& extensions,
                          const base::FilePath& temp_dir,
                          bool include_automation_extension,
                          CommandLine* command) {
   std::vector<base::FilePath::StringType> extension_paths;
@@ skipping 98 matching lines @@
   // Write empty "First Run" file, otherwise Chrome will wipe the default
   // profile that was written.
   if (file_util::WriteFile(
           user_data_dir.AppendASCII("First Run"), "", 0) != 0) {
     return Status(kUnknownError, "failed to write first run file");
   }
   return Status(kOk);
 }
 
 }  // namespace internal