[chromedriver] Remove Logger and just use base LOG.

chrome/test/chromedriver/server/chromedriver_server.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 <stdio.h>
 #include <string>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_local.h"
-#include "chrome/test/chromedriver/chrome/log.h"
 #include "chrome/test/chromedriver/chrome/version.h"
+#include "chrome/test/chromedriver/logging.h"
 #include "chrome/test/chromedriver/server/http_handler.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 #include "net/server/http_server.h"
 #include "net/server/http_server_request_info.h"
 #include "net/server/http_server_response_info.h"
 #include "net/socket/tcp_listen_socket.h"
 
-#if defined(OS_POSIX)
-#include <fcntl.h>
-#include <unistd.h>
-#endif
-
 namespace {
 
 typedef base::Callback<
     void(const net::HttpServerRequestInfo&, const HttpResponseSenderFunc&)>
     HttpRequestHandlerFunc;
 
 class HttpServer : public net::HttpServer::Delegate {
  public:
   explicit HttpServer(const HttpRequestHandlerFunc& handle_request_func)
       : handle_request_func_(handle_request_func),
@@ skipping 82 matching lines @@
 void StartServerOnIOThread(int port,
                            const HttpRequestHandlerFunc& handle_request_func) {
   scoped_ptr<HttpServer> temp_server(new HttpServer(handle_request_func));
   if (!temp_server->Start(port)) {
     printf("Port not available. Exiting...\n");
     exit(1);
   }
   lazy_tls_server.Pointer()->Set(temp_server.release());
 }
 
-void RunServer(Log::Level log_level, int port, const std::string& url_base,
-               int adb_port) {
+void RunServer(int port, const std::string& url_base, int adb_port) {
   base::Thread io_thread("ChromeDriver IO");
   CHECK(io_thread.StartWithOptions(
       base::Thread::Options(base::MessageLoop::TYPE_IO, 0)));
 
   base::MessageLoop cmd_loop;
   base::RunLoop cmd_run_loop;
-  Logger log(log_level);
   HttpHandler handler(cmd_run_loop.QuitClosure(),
                       io_thread.message_loop_proxy(),
-                      &log,
                       url_base,
                       adb_port);
   HttpRequestHandlerFunc handle_request_func =
       base::Bind(&HandleRequestOnCmdThread, &handler);
 
   io_thread.message_loop()
       ->PostTask(FROM_HERE,
                  base::Bind(&StartServerOnIOThread,
                             port,
                             base::Bind(&HandleRequestOnIOThread,
@@ skipping 14 matching lines @@
 int main(int argc, char *argv[]) {
   CommandLine::Init(argc, argv);
 
   base::AtExitManager at_exit;
   CommandLine* cmd_line = CommandLine::ForCurrentProcess();
 
   // Parse command line flags.
   int port = 9515;
   int adb_port = 5037;
   std::string url_base;
-  base::FilePath log_path;
-  Log::Level log_level = Log::kError;
   if (cmd_line->HasSwitch("h") || cmd_line->HasSwitch("help")) {
     std::string options;
     const char* kOptionAndDescriptions[] = {
         "port=PORT", "port to listen on",
         "adb-port=PORT", "adb server port",
         "log-path=FILE", "write server log to file instead of stderr, "
             "increases log level to INFO",
         "verbose", "log verbosely",
         "silent", "log nothing",
         "url-base", "base URL path prefix for commands, e.g. wd/url",
@@ skipping 18 matching lines @@
       printf("Invalid adb-port. Exiting...\n");
       return 1;
     }
   }
   if (cmd_line->HasSwitch("url-base"))
     url_base = cmd_line->GetSwitchValueASCII("url-base");
   if (url_base.empty() || url_base[0] != '/')
     url_base = "/" + url_base;
   if (url_base[url_base.length() - 1] != '/')
     url_base = url_base + "/";
-  if (cmd_line->HasSwitch("log-path")) {
-    log_level = Log::kLog;
-    log_path = cmd_line->GetSwitchValuePath("log-path");
-#if defined(OS_WIN)
-    FILE* redir_stderr = _wfreopen(log_path.value().c_str(), L"w", stderr);
-#else
-    FILE* redir_stderr = freopen(log_path.value().c_str(), "w", stderr);
-#endif
-    if (!redir_stderr) {
-      printf("Failed to redirect stderr to log file. Exiting...\n");
-      return 1;
-    }
-  }
-  if (cmd_line->HasSwitch("verbose")) {
-    log_level = Log::kDebug;
-  } else {
-#if defined(OS_POSIX)
-    // Close stderr on exec, so that Chrome log spew doesn't confuse users.
-    fcntl(STDERR_FILENO, F_SETFD, FD_CLOEXEC);
-#endif
-  }
   if (!cmd_line->HasSwitch("silent")) {
     printf(
         "Starting ChromeDriver (v%s) on port %d\n", kChromeDriverVersion, port);
     fflush(stdout);
   }
 
+  if (!InitLogging()) {
+    printf("Unable to initialize logging. Exiting...\n");
+    return 1;
+  }
 
-  logging::LoggingSettings settings;
-  settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
-  bool success = logging::InitLogging(settings);
-  if (!success) {
-    PLOG(ERROR) << "Unable to initialize logging";
-  }
-  logging::SetLogItems(false,  // enable_process_id
-                       false,  // enable_thread_id
-                       false,  // enable_timestamp
-                       false); // enable_tickcount
-  if (!cmd_line->HasSwitch("verbose"))
-    logging::SetMinLogLevel(logging::LOG_FATAL);
-
-  RunServer(log_level, port, url_base, adb_port);
+  RunServer(port, url_base, adb_port);
   return 0;
 }