Generalize the net module's LoadLog facility from a passive container, to an event stream (NetLog).

net/proxy/single_threaded_proxy_resolver.cc

 // Copyright (c) 2009 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 "net/proxy/single_threaded_proxy_resolver.h"
 
 #include "base/thread.h"
-#include "net/base/load_log.h"
+#include "net/base/net_log.h"
 #include "net/base/net_errors.h"
 #include "net/proxy/proxy_info.h"
 
 namespace net {
 
 namespace {
 
 class PurgeMemoryTask : public base::RefCountedThreadSafe<PurgeMemoryTask> {
  public:
   explicit PurgeMemoryTask(ProxyResolver* resolver) : resolver_(resolver) {}
@@ skipping 84 matching lines @@
 class SingleThreadedProxyResolver::Job
     : public base::RefCountedThreadSafe<SingleThreadedProxyResolver::Job> {
  public:
   // |coordinator| -- the SingleThreadedProxyResolver that owns this job.
   // |url|         -- the URL of the query.
   // |results|     -- the structure to fill with proxy resolve results.
   Job(SingleThreadedProxyResolver* coordinator,
       const GURL& url,
       ProxyInfo* results,
       CompletionCallback* callback,
-      LoadLog* load_log)
+      const BoundNetLog& net_log)
     : coordinator_(coordinator),
       callback_(callback),
       results_(results),
-      load_log_(load_log),
+      net_log_(net_log),
       url_(url),
       is_started_(false),
       origin_loop_(MessageLoop::current()) {
     DCHECK(callback);
   }
 
   // Start the resolve proxy request on the worker thread.
   void Start() {
     is_started_ = true;
 
-    size_t load_log_bound = load_log_ ? load_log_->max_num_entries() : 0;
+    size_t load_log_bound = 100;
 
     coordinator_->thread()->message_loop()->PostTask(
         FROM_HERE, NewRunnableMethod(this, &Job::DoQuery,
         coordinator_->resolver_.get(),
         load_log_bound));
   }
 
   bool is_started() const { return is_started_; }
 
   void Cancel() {
     // Clear these to inform QueryComplete that it should not try to
     // access them.
     coordinator_ = NULL;
     callback_ = NULL;
     results_ = NULL;
   }
 
   // Returns true if Cancel() has been called.
   bool was_cancelled() const { return callback_ == NULL; }
 
-  LoadLog* load_log() { return load_log_; }
+  BoundNetLog* net_log() { return &net_log_; }
 
  private:
   friend class base::RefCountedThreadSafe<SingleThreadedProxyResolver::Job>;
 
   ~Job() {}
 
   // Runs on the worker thread.
   void DoQuery(ProxyResolver* resolver, size_t load_log_bound) {
-    LoadLog* worker_log = NULL;
-    if (load_log_bound > 0) {
-      worker_log = new LoadLog(load_log_bound);
-      worker_log->AddRef();  // Balanced in QueryComplete.
-    }
+    scoped_ptr<CapturingNetLog> worker_log(new CapturingNetLog(load_log_bound));
+    BoundNetLog bound_worker_log(NetLog::Source(), worker_log.get());
 
     int rv = resolver->GetProxyForURL(url_, &results_buf_, NULL, NULL,
-                                      worker_log);
+                                      bound_worker_log);
     DCHECK_NE(rv, ERR_IO_PENDING);
 
     origin_loop_->PostTask(FROM_HERE,
-        NewRunnableMethod(this, &Job::QueryComplete, rv, worker_log));
+        NewRunnableMethod(this, &Job::QueryComplete, rv, worker_log.release()));
   }
 
   // Runs the completion callback on the origin thread.
-  void QueryComplete(int result_code, LoadLog* worker_log) {
+  void QueryComplete(int result_code, CapturingNetLog* worker_log) {
     // Merge the load log that was generated on the worker thread, into the
     // main log.
-    if (worker_log) {
-      if (load_log_)
-        load_log_->Append(worker_log);
-      worker_log->Release();
-    }
+    CapturingBoundNetLog bound_worker_log(NetLog::Source(), worker_log);
+    bound_worker_log.AppendTo(net_log_);
 
     // The Job may have been cancelled after it was started.
     if (!was_cancelled()) {
       if (result_code >= OK) {  // Note: unit-tests use values > 0.
         results_->Use(results_buf_);
       }
       callback_->Run(result_code);
 
       // We check for cancellation once again, in case the callback deleted
       // the owning ProxyService (whose destructor will in turn cancel us).
       if (!was_cancelled())
         coordinator_->RemoveFrontOfJobsQueueAndStartNext(this);
     }
   }
 
   // Must only be used on the "origin" thread.
   SingleThreadedProxyResolver* coordinator_;
   CompletionCallback* callback_;
   ProxyInfo* results_;
-  scoped_refptr<LoadLog> load_log_;
+  BoundNetLog net_log_;
   GURL url_;
   bool is_started_;
 
   // Usable from within DoQuery on the worker thread.
   ProxyInfo results_buf_;
   MessageLoop* origin_loop_;
 };
 
 // SingleThreadedProxyResolver ------------------------------------------------
 
@@ skipping 15 matching lines @@
     outstanding_set_pac_script_task_->Cancel();
 
   // Note that |thread_| is destroyed before |resolver_|. This is important
   // since |resolver_| could be running on |thread_|.
 }
 
 int SingleThreadedProxyResolver::GetProxyForURL(const GURL& url,
                                                 ProxyInfo* results,
                                                 CompletionCallback* callback,
                                                 RequestHandle* request,
-                                                LoadLog* load_log) {
+                                                const BoundNetLog& net_log) {
   DCHECK(callback);
 
-  scoped_refptr<Job> job = new Job(this, url, results, callback, load_log);
+  scoped_refptr<Job> job = new Job(this, url, results, callback, net_log);
   bool is_first_job = pending_jobs_.empty();
   pending_jobs_.push_back(job);  // Jobs can never finish synchronously.
 
   if (is_first_job) {
     // If there is nothing already running, start the job now.
     EnsureThreadStarted();
     job->Start();
   } else {
     // Otherwise the job will get started eventually by ProcessPendingJobs().
-    LoadLog::BeginEvent(
-        job->load_log(),
-        LoadLog::TYPE_WAITING_FOR_SINGLE_PROXY_RESOLVER_THREAD);
+    job->net_log()->BeginEvent(NetLog::TYPE_WAITING_FOR_SINGLE_PROXY_RESOLVER_THREAD);
   }
 
   // Completion will be notified through |callback|, unless the caller cancels
   // the request using |request|.
   if (request)
     *request = reinterpret_cast<RequestHandle>(job.get());
 
   return ERR_IO_PENDING;
 }
 
@@ skipping 60 matching lines @@
 
 void SingleThreadedProxyResolver::ProcessPendingJobs() {
   if (pending_jobs_.empty())
     return;
 
   // Get the next job to process (FIFO).
   Job* job = pending_jobs_.front().get();
   if (job->is_started())
     return;
 
-  LoadLog::EndEvent(
-      job->load_log(),
-      LoadLog::TYPE_WAITING_FOR_SINGLE_PROXY_RESOLVER_THREAD);
+  job->net_log()->EndEvent(
+      NetLog::TYPE_WAITING_FOR_SINGLE_PROXY_RESOLVER_THREAD);
 
   EnsureThreadStarted();
   job->Start();
 }
 
 void SingleThreadedProxyResolver::RemoveFrontOfJobsQueueAndStartNext(
     Job* expected_job) {
   DCHECK_EQ(expected_job, pending_jobs_.front().get());
   pending_jobs_.pop_front();
 
   // Start next work item.
   ProcessPendingJobs();
 }
 
 void SingleThreadedProxyResolver::RemoveOutstandingSetPacScriptTask(
     SetPacScriptTask* task) {
   DCHECK_EQ(outstanding_set_pac_script_task_.get(), task);
   outstanding_set_pac_script_task_ = NULL;
 }
 
 }  // namespace net