Update NetLog to be thread safe.

chrome/browser/net/load_timing_observer_unittest.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/format_macros.h"
 #include "base/string_util.h"
 #include "base/time.h"
@@ skipping 65 matching lines @@
 
 void AddEndSocketEntries(LoadTimingObserver& observer, uint32 id) {
   NetLog::Source source(NetLog::SOURCE_SOCKET, id);
   AddEndEntry(observer, source, NetLog::TYPE_SOCKET_ALIVE, NULL);
 }
 
 }  // namespace
 
 // Test that URLRequest with no load timing flag is not processed.
 TEST(LoadTimingObserverTest, NoLoadTimingEnabled) {
+  MessageLoop message_loop;
+  BrowserThread io_thread(BrowserThread::IO, &message_loop);

[eroman, 2010/11/30 01:43:37]

I suggest using a test fixture instead.

If I am remembering correctly, it will look something like this:


class LoadTimingObserverTest : public testing::Test {
 public:
  LoadTimingObserverTest() : io_loop_(...) {
  }
 ...
};


Then change each TEST(LoadingTimeObserverTest, ...) to:

TEST_F(LoadingTimeObserverTest, ...).

[mmenke, 2010/11/30 18:59:04]

Done.

   LoadTimingObserver observer;
 
   AddStartURLRequestEntries(observer, 0, false);
   LoadTimingObserver::URLRequestRecord* record =
       observer.GetURLRequestRecord(0);
   ASSERT_TRUE(record == NULL);
 }
 
 // Test that URLRequestRecord is created, deleted and is not growing unbound.
 TEST(LoadTimingObserverTest, URLRequestRecord) {
+  MessageLoop message_loop;
+  BrowserThread io_thread(BrowserThread::IO, &message_loop);
   LoadTimingObserver observer;
 
   // Create record.
   AddStartURLRequestEntries(observer, 0, true);
   LoadTimingObserver::URLRequestRecord* record =
       observer.GetURLRequestRecord(0);
   ASSERT_FALSE(record == NULL);
 
   // Collect record.
   AddEndURLRequestEntries(observer, 0);
   record = observer.GetURLRequestRecord(0);
   ASSERT_TRUE(record == NULL);
 
   // Check unbound growth.
   for (size_t i = 1; i < 1100; ++i)
     AddStartURLRequestEntries(observer, i, true);
   record = observer.GetURLRequestRecord(1);
   ASSERT_TRUE(record == NULL);
 }
 
 // Test that ConnectJobRecord is created, deleted and is not growing unbound.
 TEST(LoadTimingObserverTest, ConnectJobRecord) {
+  MessageLoop message_loop;
+  BrowserThread io_thread(BrowserThread::IO, &message_loop);
   LoadTimingObserver observer;
 
   // Create record.
   AddStartConnectJobEntries(observer, 0);
   ASSERT_FALSE(observer.connect_job_to_record_.find(0) ==
                    observer.connect_job_to_record_.end());
 
   // Collect record.
   AddEndConnectJobEntries(observer, 0);
   ASSERT_TRUE(observer.connect_job_to_record_.find(0) ==
                    observer.connect_job_to_record_.end());
 
   // Check unbound growth.
   for (size_t i = 1; i < 1100; ++i)
     AddStartConnectJobEntries(observer, i);
   ASSERT_TRUE(observer.connect_job_to_record_.find(1) ==
                   observer.connect_job_to_record_.end());
 }
 
 // Test that SocketRecord is created, deleted and is not growing unbound.
 TEST(LoadTimingObserverTest, SocketRecord) {
+  MessageLoop message_loop;
+  BrowserThread io_thread(BrowserThread::IO, &message_loop);
   LoadTimingObserver observer;
 
   // Create record.
   AddStartSocketEntries(observer, 0);
   ASSERT_FALSE(observer.socket_to_record_.find(0) ==
                    observer.socket_to_record_.end());
 
   // Collect record.
   AddEndSocketEntries(observer, 0);
   ASSERT_TRUE(observer.socket_to_record_.find(0) ==
                    observer.socket_to_record_.end());
 
 
   // Check unbound growth.
   for (size_t i = 1; i < 1100; ++i)
     AddStartSocketEntries(observer, i);
   ASSERT_TRUE(observer.socket_to_record_.find(1) ==
                   observer.socket_to_record_.end());
 }
 
 // Test that basic time is set to the request.
 TEST(LoadTimingObserverTest, BaseTicks) {
+  MessageLoop message_loop;
+  BrowserThread io_thread(BrowserThread::IO, &message_loop);
   LoadTimingObserver observer;
   current_time += TimeDelta::FromSeconds(1);
   AddStartURLRequestEntries(observer, 0, true);
 
   LoadTimingObserver::URLRequestRecord* record =
       observer.GetURLRequestRecord(0);
   ASSERT_EQ(1000000, record->base_ticks.ToInternalValue());
 }
 
 // Test proxy time detection.
 TEST(LoadTimingObserverTest, ProxyTime) {
+  MessageLoop message_loop;
+  BrowserThread io_thread(BrowserThread::IO, &message_loop);
   LoadTimingObserver observer;
   current_time += TimeDelta::FromSeconds(1);
 
   AddStartURLRequestEntries(observer, 0, true);
   NetLog::Source source(NetLog::SOURCE_URL_REQUEST, 0);
 
   current_time += TimeDelta::FromSeconds(2);
   AddStartEntry(observer, source, NetLog::TYPE_PROXY_SERVICE, NULL);
   current_time += TimeDelta::FromSeconds(3);
   AddEndEntry(observer, source, NetLog::TYPE_PROXY_SERVICE, NULL);
 
   LoadTimingObserver::URLRequestRecord* record =
       observer.GetURLRequestRecord(0);
   ASSERT_EQ(2000, record->timing.proxy_start);
   ASSERT_EQ(5000, record->timing.proxy_end);
 }
 
 // Test connect time detection.
 TEST(LoadTimingObserverTest, ConnectTime) {
+  MessageLoop message_loop;
+  BrowserThread io_thread(BrowserThread::IO, &message_loop);
   LoadTimingObserver observer;
   current_time += TimeDelta::FromSeconds(1);
 
   AddStartURLRequestEntries(observer, 0, true);
   NetLog::Source source(NetLog::SOURCE_URL_REQUEST, 0);
 
   current_time += TimeDelta::FromSeconds(2);
   AddStartEntry(observer, source, NetLog::TYPE_SOCKET_POOL, NULL);
   current_time += TimeDelta::FromSeconds(3);
   AddEndEntry(observer, source, NetLog::TYPE_SOCKET_POOL, NULL);
 
   LoadTimingObserver::URLRequestRecord* record =
       observer.GetURLRequestRecord(0);
   ASSERT_EQ(2000, record->timing.connect_start);
   ASSERT_EQ(5000, record->timing.connect_end);
 }
 
 // Test dns time detection.
 TEST(LoadTimingObserverTest, DnsTime) {
+  MessageLoop message_loop;
+  BrowserThread io_thread(BrowserThread::IO, &message_loop);
   LoadTimingObserver observer;
 
   // Start request.
   NetLog::Source source(NetLog::SOURCE_URL_REQUEST, 0);
   AddStartURLRequestEntries(observer, 0, true);
   current_time += TimeDelta::FromSeconds(1);
 
   // Add resolver entry.
   AddStartConnectJobEntries(observer, 1);
   NetLog::Source connect_source(NetLog::SOURCE_CONNECT_JOB, 1);
@@ skipping 14 matching lines @@
                 params.get());
 
   LoadTimingObserver::URLRequestRecord* record =
       observer.GetURLRequestRecord(0);
   ASSERT_EQ(1000, record->timing.dns_start);
   ASSERT_EQ(3000, record->timing.dns_end);
 }
 
 // Test send time detection.
 TEST(LoadTimingObserverTest, SendTime) {
+  MessageLoop message_loop;
+  BrowserThread io_thread(BrowserThread::IO, &message_loop);
   LoadTimingObserver observer;
 
   // Start request.
   NetLog::Source source(NetLog::SOURCE_URL_REQUEST, 0);
   AddStartURLRequestEntries(observer, 0, true);
   current_time += TimeDelta::FromSeconds(2);
 
   // Add send request entry.
   AddStartEntry(observer,
                 source,
                 NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST,
                 NULL);
   current_time += TimeDelta::FromSeconds(5);
   AddEndEntry(observer,
               source,
               NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST,
               NULL);
 
   LoadTimingObserver::URLRequestRecord* record =
       observer.GetURLRequestRecord(0);
   ASSERT_EQ(2000, record->timing.send_start);
   ASSERT_EQ(7000, record->timing.send_end);
 }
 
 // Test receive time detection.
 TEST(LoadTimingObserverTest, ReceiveTime) {
+  MessageLoop message_loop;
+  BrowserThread io_thread(BrowserThread::IO, &message_loop);
   LoadTimingObserver observer;
 
   // Start request.
   NetLog::Source source(NetLog::SOURCE_URL_REQUEST, 0);
   AddStartURLRequestEntries(observer, 0, true);
   current_time += TimeDelta::FromSeconds(2);
 
   // Add send request entry.
   AddStartEntry(observer,
                 source,
                 NetLog::TYPE_HTTP_TRANSACTION_READ_HEADERS,
                 NULL);
   current_time += TimeDelta::FromSeconds(5);
   AddEndEntry(observer,
               source,
               NetLog::TYPE_HTTP_TRANSACTION_READ_HEADERS,
               NULL);
 
   LoadTimingObserver::URLRequestRecord* record =
       observer.GetURLRequestRecord(0);
   ASSERT_EQ(2000, record->timing.receive_headers_start);
   ASSERT_EQ(7000, record->timing.receive_headers_end);
 }
 
 // Test ssl time detection.
 TEST(LoadTimingObserverTest, SslTime) {
+  MessageLoop message_loop;
+  BrowserThread io_thread(BrowserThread::IO, &message_loop);
   LoadTimingObserver observer;
 
   // Start request.
   NetLog::Source source(NetLog::SOURCE_URL_REQUEST, 0);
   AddStartURLRequestEntries(observer, 0, true);
   current_time += TimeDelta::FromSeconds(1);
 
   // Add resolver entry.
   AddStartSocketEntries(observer, 1);
   NetLog::Source socket_source(NetLog::SOURCE_SOCKET, 1);
   AddStartEntry(observer, socket_source, NetLog::TYPE_SSL_CONNECT, NULL);
   current_time += TimeDelta::FromSeconds(2);
   AddEndEntry(observer, socket_source, NetLog::TYPE_SSL_CONNECT, NULL);
 
   // Bind to connect job.
   scoped_refptr<net::NetLogSourceParameter> params(
       new net::NetLogSourceParameter("socket", socket_source));
   AddStartEntry(observer,
                 source,
                 NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET,
                 params.get());
 
   LoadTimingObserver::URLRequestRecord* record =
       observer.GetURLRequestRecord(0);
   ASSERT_EQ(1000, record->timing.ssl_start);
   ASSERT_EQ(3000, record->timing.ssl_end);
 }