Improve the display of LoadLogs when truncation occurs....

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_errors.h"
 #include "net/proxy/proxy_info.h"
@@ skipping 107 matching lines @@
       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;
+
     coordinator_->thread()->message_loop()->PostTask(
         FROM_HERE, NewRunnableMethod(this, &Job::DoQuery,
-        coordinator_->resolver_.get()));
+        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; }
 
  private:
   friend class base::RefCountedThreadSafe<SingleThreadedProxyResolver::Job>;
 
   ~Job() {}
 
   // Runs on the worker thread.
-  void DoQuery(ProxyResolver* resolver) {
-    LoadLog* worker_log = new LoadLog;
-    worker_log->AddRef();  // Balanced in QueryComplete.
+  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.
+    }
 
     int rv = resolver->GetProxyForURL(url_, &results_buf_, NULL, NULL,
                                       worker_log);
     DCHECK_NE(rv, ERR_IO_PENDING);
 
     origin_loop_->PostTask(FROM_HERE,
         NewRunnableMethod(this, &Job::QueryComplete, rv, worker_log));
   }
 
   // Runs the completion callback on the origin thread.
   void QueryComplete(int result_code, LoadLog* worker_log) {
     // Merge the load log that was generated on the worker thread, into the
     // main log.
-    if (load_log_)
-      load_log_->Append(worker_log);
-    worker_log->Release();
+    if (worker_log) {
+      if (load_log_)
+        load_log_->Append(worker_log);
+      worker_log->Release();
+    }
 
     // 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).
@@ skipping 140 matching lines @@
   ProcessPendingJobs();
 }
 
 void SingleThreadedProxyResolver::RemoveOutstandingSetPacScriptTask(
     SetPacScriptTask* task) {
   DCHECK_EQ(outstanding_set_pac_script_task_.get(), task);
   outstanding_set_pac_script_task_ = NULL;
 }
 
 }  // namespace net