[chromedriver] Remove Logger and just use base LOG.

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 <algorithm>
 #include <vector>
 
 #include "base/base64.h"
@@ skipping 14 matching lines @@
 #include "base/threading/platform_thread.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/test/chromedriver/chrome/chrome_android_impl.h"
 #include "chrome/test/chromedriver/chrome/chrome_desktop_impl.h"
 #include "chrome/test/chromedriver/chrome/chrome_existing_impl.h"
 #include "chrome/test/chromedriver/chrome/chrome_finder.h"
 #include "chrome/test/chromedriver/chrome/device_manager.h"
 #include "chrome/test/chromedriver/chrome/devtools_http_client.h"
 #include "chrome/test/chromedriver/chrome/embedded_automation_extension.h"
-#include "chrome/test/chromedriver/chrome/log.h"
 #include "chrome/test/chromedriver/chrome/status.h"
 #include "chrome/test/chromedriver/chrome/user_data_dir.h"
 #include "chrome/test/chromedriver/chrome/version.h"
 #include "chrome/test/chromedriver/chrome/web_view.h"
 #include "chrome/test/chromedriver/chrome/zip.h"
 #include "chrome/test/chromedriver/net/net_util.h"
 #include "chrome/test/chromedriver/net/url_request_context_getter.h"
 #include "crypto/sha2.h"
 
 namespace {
@@ skipping 94 matching lines @@
     return status;
   switches.AppendToCommandLine(&command);
   *prepared_command = command;
   return Status(kOk);
 }
 
 Status WaitForDevToolsAndCheckVersion(
     const NetAddress& address,
     URLRequestContextGetter* context_getter,
     const SyncWebSocketFactory& socket_factory,
-    Log* log,
     scoped_ptr<DevToolsHttpClient>* user_client) {
   scoped_ptr<DevToolsHttpClient> client(new DevToolsHttpClient(
-      address, context_getter, socket_factory, log));
+      address, context_getter, socket_factory));
   base::TimeTicks deadline =
       base::TimeTicks::Now() + base::TimeDelta::FromSeconds(20);
   Status status = client->Init(deadline - base::TimeTicks::Now());
   if (status.IsError())
     return status;
   if (client->build_no() < kMinimumSupportedChromeBuildNo) {
     return Status(kUnknownError, "Chrome version must be >= " +
         GetMinimumSupportedChromeVersion());
   }
 
   while (base::TimeTicks::Now() < deadline) {
     WebViewsInfo views_info;
     client->GetWebViewsInfo(&views_info);
     for (size_t i = 0; i < views_info.GetSize(); ++i) {
       if (views_info.Get(i).type == WebViewInfo::kPage) {
         *user_client = client.Pass();
         return Status(kOk);
       }
     }
     base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(50));
   }
   return Status(kUnknownError, "unable to discover open pages");
 }
 
 Status LaunchExistingChromeSession(
     URLRequestContextGetter* context_getter,
     const SyncWebSocketFactory& socket_factory,
-    Log* log,
     const Capabilities& capabilities,
     ScopedVector<DevToolsEventListener>& devtools_event_listeners,
     scoped_ptr<Chrome>* chrome) {
   Status status(kOk);
   scoped_ptr<DevToolsHttpClient> devtools_client;
   status = WaitForDevToolsAndCheckVersion(
-      capabilities.debugger_address, context_getter, socket_factory, log,
+      capabilities.debugger_address, context_getter, socket_factory,
       &devtools_client);
   if (status.IsError()) {
     return Status(kUnknownError, "cannot connect to chrome at " +
                       capabilities.debugger_address.ToString(),
                   status);
   }
   chrome->reset(new ChromeExistingImpl(devtools_client.Pass(),
-      devtools_event_listeners,
-      log));
+                                       devtools_event_listeners));
   return Status(kOk);
 }
 
 Status LaunchDesktopChrome(
     URLRequestContextGetter* context_getter,
     int port,
     const SyncWebSocketFactory& socket_factory,
-    Log* log,
     const Capabilities& capabilities,
     ScopedVector<DevToolsEventListener>& devtools_event_listeners,
     scoped_ptr<Chrome>* chrome) {
   CommandLine command(CommandLine::NO_PROGRAM);
   base::ScopedTempDir user_data_dir;
   base::ScopedTempDir extension_dir;
   std::vector<std::string> extension_bg_pages;
   Status status = PrepareCommandLine(port,
                                      capabilities,
                                      &command,
@@ skipping 10 matching lines @@
     options.environ["CHROME_LOG_FILE"] = capabilities.log_path;
   if (capabilities.detach)
     options.new_process_group = true;
 #endif
 
 #if defined(OS_WIN)
   std::string command_string = base::WideToUTF8(command.GetCommandLineString());
 #else
   std::string command_string = command.GetCommandLineString();
 #endif
-  log->AddEntry(Log::kLog, "Launching chrome: " + command_string);
+  VLOG(0) << "Launching chrome: " << command_string;
   base::ProcessHandle process;
   if (!base::LaunchProcess(command, options, &process))
     return Status(kUnknownError, "chrome failed to start");
 
   scoped_ptr<DevToolsHttpClient> devtools_client;
   status = WaitForDevToolsAndCheckVersion(
-      NetAddress(port), context_getter, socket_factory, log, &devtools_client);
+      NetAddress(port), context_getter, socket_factory, &devtools_client);
 
   if (status.IsError()) {
     int exit_code;
     base::TerminationStatus chrome_status =
         base::GetTerminationStatus(process, &exit_code);
     if (chrome_status != base::TERMINATION_STATUS_STILL_RUNNING) {
       std::string termination_reason;
       switch (chrome_status) {
         case base::TERMINATION_STATUS_NORMAL_TERMINATION:
           termination_reason = "exited normally";
@@ skipping 18 matching lines @@
       int exit_code;
       if (base::GetTerminationStatus(process, &exit_code) ==
           base::TERMINATION_STATUS_STILL_RUNNING)
         return Status(kUnknownError, "cannot kill Chrome", status);
     }
     return status;
   }
   scoped_ptr<ChromeDesktopImpl> chrome_desktop(
       new ChromeDesktopImpl(devtools_client.Pass(),
                             devtools_event_listeners,
-                            log,
                             process,
                             &user_data_dir,
                             &extension_dir));
   for (size_t i = 0; i < extension_bg_pages.size(); ++i) {
     scoped_ptr<WebView> web_view;
     Status status = chrome_desktop->WaitForPageToLoad(
         extension_bg_pages[i], base::TimeDelta::FromSeconds(10), &web_view);
     if (status.IsError()) {
       return Status(kUnknownError,
                     "failed to wait for extension background page to load: " +
                         extension_bg_pages[i],
                     status);
     }
   }
   *chrome = chrome_desktop.Pass();
   return Status(kOk);
 }
 
 Status LaunchAndroidChrome(
     URLRequestContextGetter* context_getter,
     int port,
     const SyncWebSocketFactory& socket_factory,
-    Log* log,
     const Capabilities& capabilities,
     ScopedVector<DevToolsEventListener>& devtools_event_listeners,
     DeviceManager* device_manager,
     scoped_ptr<Chrome>* chrome) {
   Status status(kOk);
   scoped_ptr<Device> device;
   if (capabilities.android_device_serial.empty()) {
     status = device_manager->AcquireDevice(&device);
   } else {
     status = device_manager->AcquireSpecificDevice(
@@ skipping 13 matching lines @@
                             switches.ToString(), port);
   if (!status.IsOk()) {
     device->StopApp();
     return status;
   }
 
   scoped_ptr<DevToolsHttpClient> devtools_client;
   status = WaitForDevToolsAndCheckVersion(NetAddress(port),
                                           context_getter,
                                           socket_factory,
-                                          log,
                                           &devtools_client);
   if (status.IsError())
     return status;
 
   chrome->reset(new ChromeAndroidImpl(
-      devtools_client.Pass(), devtools_event_listeners, device.Pass(), log));
+      devtools_client.Pass(), devtools_event_listeners, device.Pass()));
   return Status(kOk);
 }
 
 }  // namespace
 
 Status LaunchChrome(
     URLRequestContextGetter* context_getter,
     const SyncWebSocketFactory& socket_factory,
-    Log* log,
     DeviceManager* device_manager,
     const Capabilities& capabilities,
     ScopedVector<DevToolsEventListener>& devtools_event_listeners,
     scoped_ptr<Chrome>* chrome) {
   if (capabilities.IsExistingBrowser()) {
     return LaunchExistingChromeSession(
         context_getter, socket_factory,
-        log, capabilities, devtools_event_listeners, chrome);
+        capabilities, devtools_event_listeners, chrome);
   }
 
   int port;
   if (!FindOpenPort(&port))
     return Status(kUnknownError, "failed to find an open port for Chrome");
 
   if (capabilities.IsAndroid()) {
     return LaunchAndroidChrome(
-        context_getter, port, socket_factory, log, capabilities,
+        context_getter, port, socket_factory, capabilities,
         devtools_event_listeners, device_manager, chrome);
   } else {
     return LaunchDesktopChrome(
-        context_getter, port, socket_factory, log, capabilities,
+        context_getter, port, socket_factory, capabilities,
         devtools_event_listeners, chrome);
   }
 }
 
 namespace internal {
 
 void ConvertHexadecimalToIDAlphabet(std::string* id) {
   for (size_t i = 0; i < id->size(); ++i) {
     int val;
     if (base::HexStringToInt(base::StringPiece(id->begin() + i,
@@ skipping 213 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