[chromedriver] Remove Logger and just use base LOG.

chrome/test/chromedriver/commands.cc

 // Copyright (c) 2012 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/commands.h"
 
 #include <list>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 38 matching lines @@
   os.SetString("arch", base::SysInfo::OperatingSystemArchitecture());
 
   base::DictionaryValue info;
   info.Set("build", build.DeepCopy());
   info.Set("os", os.DeepCopy());
   callback.Run(
       Status(kOk), scoped_ptr<base::Value>(info.DeepCopy()), std::string());
 }
 
 NewSessionParams::NewSessionParams(
-    Log* log,
     SessionThreadMap* session_thread_map,
     scoped_refptr<URLRequestContextGetter> context_getter,
     const SyncWebSocketFactory& socket_factory,
     DeviceManager* device_manager)
-    : log(log),
-      session_thread_map(session_thread_map),
+    : session_thread_map(session_thread_map),
       context_getter(context_getter),
       socket_factory(socket_factory),
       device_manager(device_manager) {}
 
 NewSessionParams::~NewSessionParams() {}
 
 namespace {
 
 base::LazyInstance<base::ThreadLocalPointer<Session> >
     lazy_tls_session = LAZY_INSTANCE_INITIALIZER;
 
 Status CreateSessionOnSessionThreadHelper(
     const NewSessionParams& bound_params,
     const base::DictionaryValue& params,
     const std::string& session_id,
     scoped_ptr<base::Value>* out_value) {
   const base::DictionaryValue* desired_caps;
   if (!params.GetDictionary("desiredCapabilities", &desired_caps))
     return Status(kUnknownError, "cannot find dict 'desiredCapabilities'");
 
   Capabilities capabilities;
-  Status status = capabilities.Parse(*desired_caps, bound_params.log);
+  Status status = capabilities.Parse(*desired_caps);
   if (status.IsError())
     return status;
 
   // Create Log's and DevToolsEventListener's for ones that are DevTools-based.
   // Session will own the Log's, Chrome will own the listeners.
   ScopedVector<WebDriverLog> devtools_logs;
+  // TODO(kkania): Save this log in the session.
+  scoped_ptr<WebDriverLog> driver_log;
   ScopedVector<DevToolsEventListener> devtools_event_listeners;
-  status = CreateLogs(capabilities, &devtools_logs, &devtools_event_listeners);
+  status = CreateLogs(
+      capabilities, &devtools_logs, &driver_log, &devtools_event_listeners);
   if (status.IsError())
     return status;
 
   scoped_ptr<Chrome> chrome;
   status = LaunchChrome(bound_params.context_getter.get(),
                         bound_params.socket_factory,
-                        bound_params.log,
                         bound_params.device_manager,
                         capabilities,
                         devtools_event_listeners,
                         &chrome);
   if (status.IsError())
     return status;
 
   std::list<std::string> web_view_ids;
   status = chrome->GetWebViewIds(&web_view_ids);
   if (status.IsError() || web_view_ids.empty()) {
@@ skipping 175 matching lines @@
   }
 }
 
 namespace internal {
 
 void CreateSessionOnSessionThreadForTesting(const std::string& id) {
   lazy_tls_session.Pointer()->Set(new Session(id));
 }
 
 }  // namespace internal