Refactor net::NetLog to provide implementation of observer pattern, not just the interface.

net/tools/get_server_time/get_server_time.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.
 
 // This is a small utility that snarfs the server time from the
 // response headers of an http/https HEAD request and compares it to
 // the local time.
 //
 // TODO(akalin): Also snarf the server time from the TLS handshake, if
 // any (http://crbug.com/146090).
@@ skipping 85 matching lines @@
 
   virtual void OnURLFetchUploadProgress(const net::URLFetcher* source,
                                         int64 current, int64 total) OVERRIDE {
     NOTREACHED();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(QuitDelegate);
 };
 
-// NetLog implementation that simply prints events to the logs.
-class PrintingLog : public net::NetLog {
+// NetLog::ThreadSafeObserver implementation that simply prints events
+// to the logs.
+class PrintingLogObserver : public net::NetLog::ThreadSafeObserver {
  public:
-  PrintingLog() : next_id_(1) {}
+  PrintingLogObserver() {}
 
-  virtual ~PrintingLog() {}
+  virtual ~PrintingLogObserver() {
+    // This is guaranteed to be safe as this program is single threaded.
+    net_log()->RemoveThreadSafeObserver(this);
+  }
 
-  // NetLog implementation:
+  // NetLog::ThreadSafeObserver implementation:
   virtual void OnAddEntry(const net::NetLog::Entry& entry) OVERRIDE {
     // The log level of the entry is unknown, so just assume it maps
     // to VLOG(1).
     if (!VLOG_IS_ON(1))
       return;
 
     const char* const source_type =
         net::NetLog::SourceTypeToString(entry.source().type);
     const char* const event_type =
         net::NetLog::EventTypeToString(entry.type());
     const char* const event_phase =
         net::NetLog::EventPhaseToString(entry.phase());
     scoped_ptr<base::Value> params(entry.ParametersToValue());
     std::string params_str;
     if (params.get()) {
       base::JSONWriter::Write(params.get(), &params_str);
       params_str.insert(0, ": ");
     }
 
     VLOG(1) << source_type << "(" << entry.source().id << "): "
             << event_type << ": " << event_phase << params_str;
   }
 
-  virtual uint32 NextID() OVERRIDE {
-    return next_id_++;
-  }
-
-  virtual LogLevel GetLogLevel() const OVERRIDE {
-    const int vlog_level = logging::GetVlogLevel(__FILE__);
-    if (vlog_level <= 0) {
-      return LOG_BASIC;
-    }
-    if (vlog_level == 1) {
-      return LOG_ALL_BUT_BYTES;
-    }
-    return LOG_ALL;
-  }
-
-  virtual void AddThreadSafeObserver(ThreadSafeObserver* observer,
-                                     LogLevel log_level) OVERRIDE {
-    NOTIMPLEMENTED();
-  }
-
-  virtual void SetObserverLogLevel(ThreadSafeObserver* observer,
-                                   LogLevel log_level) OVERRIDE {
-    NOTIMPLEMENTED();
-  }
-
-  virtual void RemoveThreadSafeObserver(ThreadSafeObserver* observer) OVERRIDE {
-    NOTIMPLEMENTED();
-  }
-
  private:
-  uint32 next_id_;
-
-  DISALLOW_COPY_AND_ASSIGN(PrintingLog);
+  DISALLOW_COPY_AND_ASSIGN(PrintingLogObserver);
 };
 
 // Builds a URLRequestContext assuming there's only a single loop.
-scoped_ptr<net::URLRequestContext> BuildURLRequestContext() {
+scoped_ptr<net::URLRequestContext>
+BuildURLRequestContext(net::NetLog* net_log) {
   net::URLRequestContextBuilder builder;
 #if defined(OS_LINUX)
   // On Linux, use a fixed ProxyConfigService, since the default one
   // depends on glib.
   //
   // TODO(akalin): Remove this once http://crbug.com/146421 is fixed.
   builder.set_proxy_config_service(
       new net::ProxyConfigServiceFixed(net::ProxyConfig()));
 #endif
   scoped_ptr<net::URLRequestContext> context(builder.Build());
-  context->set_net_log(new PrintingLog());
+  context->set_net_log(net_log);
   return context.Pass();
 }
 
 class SingleThreadRequestContextGetter : public net::URLRequestContextGetter {
  public:
   // Since there's only a single thread, there's no need to worry
   // about when |context_| gets created.
-  explicit SingleThreadRequestContextGetter(
+  SingleThreadRequestContextGetter(
+      net::NetLog* net_log,
       const scoped_refptr<base::SingleThreadTaskRunner>& main_task_runner)
-      : context_(BuildURLRequestContext()),
+      : context_(BuildURLRequestContext(net_log)),
         main_task_runner_(main_task_runner) {}
 
   virtual net::URLRequestContext* GetURLRequestContext() OVERRIDE {
     return context_.get();
   }
 
   virtual scoped_refptr<base::SingleThreadTaskRunner>
   GetNetworkTaskRunner() const OVERRIDE {
     return main_task_runner_;
   }
@@ skipping 68 matching lines @@
     return EXIT_FAILURE;
   }
 
   base::MessageLoopForIO main_loop;
 
   // NOTE: A NetworkChangeNotifier could be instantiated here, but
   // that interferes with the request that will be sent; some
   // implementations always send out an OnIPAddressChanged() message,
   // which causes the DNS resolution to abort.  It's simpler to just
   // not instantiate one, since only a single request is sent anyway.
-
+  net::NetLog net_log;
+  PrintingLogObserver printing_log_observer;

[mmenke, 2013/06/05 16:22:14]

Suggest commenting that this order is important for proper cleanup (To avoid it
looking that like the two comments are related, suggest a blank, commentless
line between two two).

[kouhei (in TOK), 2013/06/06 00:49:40]

Done.

+  net_log.AddThreadSafeObserver(&printing_log_observer, net::NetLog::LOG_ALL);
   scoped_refptr<SingleThreadRequestContextGetter> context_getter(
-      new SingleThreadRequestContextGetter(main_loop.message_loop_proxy()));
+      new SingleThreadRequestContextGetter(&net_log,
+                                           main_loop.message_loop_proxy()));
 
   QuitDelegate delegate;
   scoped_ptr<net::URLFetcher> fetcher(
       net::URLFetcher::Create(url, net::URLFetcher::HEAD, &delegate));
   fetcher->SetRequestContext(context_getter.get());
 
   const base::Time start_time = base::Time::Now();
   const base::TimeTicks start_ticks = base::TimeTicks::Now();
 
   fetcher->Start();
@@ skipping 69 matching lines @@
                &skew, &skew_uncertainty);
 
   std::printf(
       "An estimate for the local clock skew is %.2f ms with "
       "uncertainty %.2f ms\n",
       skew.InMillisecondsF(),
       skew_uncertainty.InMillisecondsF());
 
   return EXIT_SUCCESS;
 }