Update NetLog to be thread safe.

chrome/browser/net/load_timing_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/net/load_timing_observer.h"
 
 #include "base/compiler_specific.h"
 #include "base/time.h"
 #include "chrome/browser/net/chrome_net_log.h"
 #include "chrome/common/resource_response.h"
@@ skipping 26 matching lines @@
                                  tick_to_time_offset);
 }
 
 static int32 TimeTicksToOffset(
     const TimeTicks& time_ticks,
     LoadTimingObserver::URLRequestRecord* record) {
   return static_cast<int32>(
       (time_ticks - record->base_ticks).InMillisecondsRoundedUp());
 }
 
-}
+}  // namespace
 
 LoadTimingObserver::URLRequestRecord::URLRequestRecord()
     : connect_job_id(net::NetLog::Source::kInvalidId),
       socket_log_id(net::NetLog::Source::kInvalidId),
       socket_reused(false) {
 }
 
 LoadTimingObserver::LoadTimingObserver()
-    : Observer(net::NetLog::LOG_BASIC),
+    : ThreadSafeObserver(net::NetLog::LOG_BASIC),
       last_connect_job_id_(net::NetLog::Source::kInvalidId) {
 }
 
 LoadTimingObserver::~LoadTimingObserver() {
 }
 
 LoadTimingObserver::URLRequestRecord*
 LoadTimingObserver::GetURLRequestRecord(uint32 source_id) {
   URLRequestToRecordMap::iterator it = url_request_to_record_.find(source_id);
   if (it != url_request_to_record_.end())
     return &it->second;
   return NULL;
 }
 
 void LoadTimingObserver::OnAddEntry(net::NetLog::EventType type,
                                     const base::TimeTicks& time,
                                     const net::NetLog::Source& source,
                                     net::NetLog::EventPhase phase,
                                     net::NetLog::EventParameters* params) {
+  // The events that the Observer is interested in only occur on the IO thread.
+  if (!BrowserThread::CurrentlyOn(BrowserThread::IO))
+    return;
   if (source.type == net::NetLog::SOURCE_URL_REQUEST)
     OnAddURLRequestEntry(type, time, source, phase, params);
   else if (source.type == net::NetLog::SOURCE_CONNECT_JOB)
     OnAddConnectJobEntry(type, time, source, phase, params);
   else if (source.type == net::NetLog::SOURCE_SOCKET)
     OnAddSocketEntry(type, time, source, phase, params);
 }
 
 // static
 void LoadTimingObserver::PopulateTimingInfo(URLRequest* request,
                                             ResourceResponse* response) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!(request->load_flags() & net::LOAD_ENABLE_LOAD_TIMING))
     return;
 
   ChromeNetLog* chrome_net_log = static_cast<ChromeNetLog*>(
       request->net_log().net_log());
   if (chrome_net_log == NULL)
     return;
 
   uint32 source_id = request->net_log().source().id;
   LoadTimingObserver* observer = chrome_net_log->load_timing_observer();
   LoadTimingObserver::URLRequestRecord* record =
       observer->GetURLRequestRecord(source_id);
   if (record) {
     response->response_head.connection_id = record->socket_log_id;
     response->response_head.connection_reused = record->socket_reused;
     response->response_head.load_timing = record->timing;
   }
 }
 
 void LoadTimingObserver::OnAddURLRequestEntry(
     net::NetLog::EventType type,
     const base::TimeTicks& time,
     const net::NetLog::Source& source,
     net::NetLog::EventPhase phase,
     net::NetLog::EventParameters* params) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
   bool is_begin = phase == net::NetLog::PHASE_BEGIN;
   bool is_end = phase == net::NetLog::PHASE_END;
 
   if (type == net::NetLog::TYPE_URL_REQUEST_START_JOB) {
     if (is_begin) {
       // Only record timing for entries with corresponding flag.
       int load_flags = static_cast<URLRequestStartEventParameters*>(params)->
           load_flags();
       if (!(load_flags & net::LOAD_ENABLE_LOAD_TIMING))
         return;
@@ skipping 81 matching lines @@
       break;
   }
 }
 
 void LoadTimingObserver::OnAddConnectJobEntry(
     net::NetLog::EventType type,
     const base::TimeTicks& time,
     const net::NetLog::Source& source,
     net::NetLog::EventPhase phase,
     net::NetLog::EventParameters* params) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
   bool is_begin = phase == net::NetLog::PHASE_BEGIN;
   bool is_end = phase == net::NetLog::PHASE_END;
 
   // Manage record lifetime based on the SOCKET_POOL_CONNECT_JOB entry.
   if (type == net::NetLog::TYPE_SOCKET_POOL_CONNECT_JOB) {
     if (is_begin) {
       // Prevents us from passively growing the memory memory unbounded in case
       // something went wrong. Should not happen.
       if (connect_job_to_record_.size() > kMaxNumEntries) {
         LOG(WARNING) << "The load timing observer connect job count has grown "
@@ skipping 23 matching lines @@
     }
   }
 }
 
 void LoadTimingObserver::OnAddSocketEntry(
     net::NetLog::EventType type,
     const base::TimeTicks& time,
     const net::NetLog::Source& source,
     net::NetLog::EventPhase phase,
     net::NetLog::EventParameters* params) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
   bool is_begin = phase == net::NetLog::PHASE_BEGIN;
   bool is_end = phase == net::NetLog::PHASE_END;
 
   // Manage record lifetime based on the SOCKET_ALIVE entry.
   if (type == net::NetLog::TYPE_SOCKET_ALIVE) {
     if (is_begin) {
       // Prevents us from passively growing the memory memory unbounded in case
       // something went wrong. Should not happen.
       if (socket_to_record_.size() > kMaxNumEntries) {
         LOG(WARNING) << "The load timing observer socket count has grown "
@@ skipping 12 matching lines @@
   if (it == socket_to_record_.end())
     return;
 
   if (type == net::NetLog::TYPE_SSL_CONNECT) {
     if (is_begin)
       it->second.ssl_start = time;
     else if (is_end)
       it->second.ssl_end = time;
   }
 }