Update NetLog to be thread safe.

chrome/browser/debugger/devtools_netlog_observer.cc

 // Copyright (c) 2010 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/browser/debugger/devtools_netlog_observer.h"
 
 #include "base/string_util.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/common/resource_response.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_net_log_params.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_netlog_params.h"
 #include "webkit/glue/resource_loader_bridge.h"
 
+namespace {
+
+void AddEntryOnIOThread(
+    DevToolsNetLogObserver* observer,
+    net::NetLog::EventType type,
+    const base::TimeTicks& time,
+    const net::NetLog::Source& source,
+    net::NetLog::EventPhase phase,
+    scoped_refptr<net::NetLog::EventParameters> params) {
+  if (observer == DevToolsNetLogObserver::GetInstance()) {
+    observer->OnAddEntry(type, time, source, phase, params.get());
+  }
+}
+
+}  // namespace
+
 const size_t kMaxNumEntries = 1000;
 
 DevToolsNetLogObserver* DevToolsNetLogObserver::instance_ = NULL;
 
 DevToolsNetLogObserver::DevToolsNetLogObserver(ChromeNetLog* chrome_net_log)
     : ChromeNetLog::Observer(net::NetLog::LOG_ALL_BUT_BYTES),
       chrome_net_log_(chrome_net_log) {
   chrome_net_log_->AddObserver(this);
 }
 
 DevToolsNetLogObserver::~DevToolsNetLogObserver() {
   chrome_net_log_->RemoveObserver(this);
 }
 
 DevToolsNetLogObserver::ResourceInfo*
 DevToolsNetLogObserver::GetResourceInfo(uint32 id) {
   RequestToInfoMap::iterator it = request_to_info_.find(id);
   if (it != request_to_info_.end())
     return it->second;
   return NULL;
 }
 
 void DevToolsNetLogObserver::OnAddEntry(net::NetLog::EventType type,
                                         const base::TimeTicks& time,
                                         const net::NetLog::Source& source,
                                         net::NetLog::EventPhase phase,
                                         net::NetLog::EventParameters* params) {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
+    BrowserThread::PostTask(BrowserThread::IO,

[eroman, 2010/11/16 17:51:14]

Can we instead just return immediately if we aren't on the IO thread?

It looks like the only events which the DevToolsNetLogObserver is interested in
anyway are things emitted on the IO thread (i.e. the existing set of events).

[mmenke, 2010/11/16 21:34:49]

I'm not quite sure, actually.  Do we care about the events from the proxy
resolver or not?  They occur on a worker thread and used to use a
ForwardingNetLog, but are now sent to the NetLog directly.

I've done as you suggest, for now, though I'm also a bit concerned about the
non-obvious dependency this creates between this class's implementation and
which threads certain events themselves are logged on.

+                            FROM_HERE,
+                            NewRunnableFunction(
+                                AddEntryOnIOThread,
+                                this, type, time, source, phase,
+                                make_scoped_refptr(params)));
+    return;
+  }
+
   if (type == net::NetLog::TYPE_URL_REQUEST_START_JOB) {
     if (phase != net::NetLog::PHASE_BEGIN)
       return;
     int load_flags = static_cast<URLRequestStartEventParameters*>(params)->
         load_flags();
     if (!(load_flags & net::LOAD_REPORT_RAW_HEADERS))
       return;
     if (request_to_info_.size() > kMaxNumEntries) {
       LOG(WARNING) << "The raw headers observer url request count has grown "
                       "larger than expected, resetting";
@@ skipping 39 matching lines @@
     }
     default:
       break;
   }
 }
 
 void DevToolsNetLogObserver::Attach(IOThread* io_thread) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!instance_);
 
-  instance_ = new DevToolsNetLogObserver(io_thread->globals()->net_log.get());
+  instance_ = new DevToolsNetLogObserver(io_thread->net_log());
 }
 
 void DevToolsNetLogObserver::Detach() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(instance_);
 
   delete instance_;
   instance_ = NULL;
 }
 
@@ skipping 10 matching lines @@
     return;
 
   uint32 source_id = request->net_log().source().id;
   DevToolsNetLogObserver* dev_tools_net_log_observer =
       DevToolsNetLogObserver::GetInstance();
   if (!dev_tools_net_log_observer)
     return;
   response->response_head.devtools_info =
       dev_tools_net_log_observer->GetResourceInfo(source_id);
 }