[chromedriver] Remove Logger and just use base LOG.

chrome/test/chromedriver/server/http_handler.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/server/http_handler.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
@@ skipping 38 matching lines @@
 
 }  // namespace
 
 CommandMapping::CommandMapping(HttpMethod method,
                                const std::string& path_pattern,
                                const Command& command)
     : method(method), path_pattern(path_pattern), command(command) {}
 
 CommandMapping::~CommandMapping() {}
 
-HttpHandler::HttpHandler(Log* log, const std::string& url_base)
-    : log_(log),
-      url_base_(url_base),
+HttpHandler::HttpHandler(const std::string& url_base)
+    : url_base_(url_base),
       received_shutdown_(false),
       command_map_(new CommandMap()),
       weak_ptr_factory_(this) {}
 
 HttpHandler::HttpHandler(
     const base::Closure& quit_func,
     const scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
-    Log* log,
     const std::string& url_base,
     int adb_port)
     : quit_func_(quit_func),
-      log_(log),
       url_base_(url_base),
       received_shutdown_(false),
       weak_ptr_factory_(this) {
 #if defined(OS_MACOSX)
   base::mac::ScopedNSAutoreleasePool autorelease_pool;
 #endif
   context_getter_ = new URLRequestContextGetter(io_task_runner);
   socket_factory_ = CreateSyncWebSocketFactory(context_getter_.get());
-  adb_.reset(new AdbImpl(io_task_runner, log_, adb_port));
+  adb_.reset(new AdbImpl(io_task_runner, adb_port));
   device_manager_.reset(new DeviceManager(adb_.get()));
 
   CommandMapping commands[] = {
       CommandMapping(kPost,
                      internal::kNewSessionPathPattern,
                      base::Bind(&ExecuteNewSession,
-                                NewSessionParams(log_,
-                                                 &session_thread_map_,
+                                NewSessionParams(&session_thread_map_,
                                                  context_getter_,
                                                  socket_factory_,
                                                  device_manager_.get()))),
       CommandMapping(kGet,
                      "session/:sessionId",
                      WrapToCommand(base::Bind(&ExecuteGetSessionCapabilities))),
       CommandMapping(kDelete,
                      "session/:sessionId",
                      base::Bind(&ExecuteSessionCommand,
                                 &session_thread_map_,
@@ skipping 383 matching lines @@
 Command HttpHandler::WrapToCommand(
     const ElementCommand& element_command) {
   return WrapToCommand(
       base::Bind(&ExecuteElementCommand, element_command));
 }
 
 void HttpHandler::HandleCommand(
     const net::HttpServerRequestInfo& request,
     const std::string& trimmed_path,
     const HttpResponseSenderFunc& send_response_func) {
-  log_->AddEntry(Log::kLog,
-                 base::StringPrintf("handling command: %s %s %s",
-                                    request.method.c_str(),
-                                    trimmed_path.c_str(),
-                                    request.data.c_str()));
+  if (IsVLogOn(0)) {
+    VLOG(0) << "Handling command: " << request.method << " " << trimmed_path
+            << " " << FormatJsonForDisplay(request.data);
+  }
 
   base::DictionaryValue params;
   std::string session_id;
   CommandMap::const_iterator iter = command_map_->begin();
   while (true) {
     if (iter == command_map_->end()) {
       scoped_ptr<net::HttpServerResponseInfo> response(
           new net::HttpServerResponseInfo(net::HTTP_NOT_FOUND));
       response->SetBody("unknown command: " + trimmed_path, "text/plain");
       send_response_func.Run(response.Pass());
@@ skipping 29 matching lines @@
 
 void HttpHandler::PrepareResponse(
     const std::string& trimmed_path,
     const HttpResponseSenderFunc& send_response_func,
     const Status& status,
     scoped_ptr<base::Value> value,
     const std::string& session_id) {
   CHECK(thread_checker_.CalledOnValidThread());
   scoped_ptr<net::HttpServerResponseInfo> response =
       PrepareResponseHelper(trimmed_path, status, value.Pass(), session_id);
-  log_->AddEntry(Log::kLog,
-                 base::StringPrintf("sending response: %d %s",
-                                    response->status_code(),
-                                    response->body().c_str()));
+  if (IsVLogOn(0)) {
+    VLOG(0) << "Sending response: " << response->status_code() << " "
+            << FormatJsonForDisplay(response->body());
+  }
   send_response_func.Run(response.Pass());
   if (trimmed_path == kShutdownPath)
     quit_func_.Run();
 }
 
 scoped_ptr<net::HttpServerResponseInfo> HttpHandler::PrepareResponseHelper(
     const std::string& trimmed_path,
     const Status& status,
     scoped_ptr<base::Value> value,
     const std::string& session_id) {
@@ skipping 86 matching lines @@
         params.SetString(name, path_parts[i]);
     } else if (command_path_parts[i] != path_parts[i]) {
       return false;
     }
   }
   out_params->MergeDictionary(&params);
   return true;
 }
 
 }  // namespace internal