Get rid of TestNetLog::CapturedEntry[List] typedefs.

net/http/http_cache_unittest.cc

 // Copyright (c) 2012 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/http/http_cache.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 16 matching lines @@
 #include "net/http/http_byte_range.h"
 #include "net/http/http_cache_transaction.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_transaction.h"
 #include "net/http/http_transaction_test_util.h"
 #include "net/http/http_util.h"
 #include "net/http/mock_http_cache.h"
+#include "net/log/captured_net_log_entry.h"
 #include "net/log/net_log_unittest.h"
+#include "net/log/test_net_log.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/ssl/ssl_cert_request_info.h"
 #include "net/websockets/websocket_handshake_stream_base.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::Time;
 
 namespace net {
 
 namespace {
@@ skipping 477 matching lines @@
   WebSocketHandshakeStreamBase* CreateSpdyStream(
       const base::WeakPtr<SpdySession>& session,
       bool use_relative_url) override {
     return NULL;
   }
 };
 
 // Returns true if |entry| is not one of the log types paid attention to in this
 // test. Note that TYPE_HTTP_CACHE_WRITE_INFO and TYPE_HTTP_CACHE_*_DATA are
 // ignored.
-bool ShouldIgnoreLogEntry(const TestNetLog::CapturedEntry& entry) {
+bool ShouldIgnoreLogEntry(const CapturedNetLogEntry& entry) {
   switch (entry.type) {
     case NetLog::TYPE_HTTP_CACHE_GET_BACKEND:
     case NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY:
     case NetLog::TYPE_HTTP_CACHE_CREATE_ENTRY:
     case NetLog::TYPE_HTTP_CACHE_ADD_TO_ENTRY:
     case NetLog::TYPE_HTTP_CACHE_DOOM_ENTRY:
     case NetLog::TYPE_HTTP_CACHE_READ_INFO:
       return false;
     default:
       return true;
   }
 }
 
 // Modifies |entries| to only include log entries created by the cache layer and
 // asserted on in these tests.
-void FilterLogEntries(TestNetLog::CapturedEntryList* entries) {
+void FilterLogEntries(CapturedNetLogEntry::List* entries) {
   entries->erase(std::remove_if(entries->begin(), entries->end(),
                                 &ShouldIgnoreLogEntry),
                  entries->end());
 }
 
 bool LogContainsEventType(const BoundTestNetLog& log,
                           NetLog::EventType expected) {
-  TestNetLog::CapturedEntryList entries;
+  CapturedNetLogEntry::List entries;
   log.GetEntries(&entries);
   for (size_t i = 0; i < entries.size(); i++) {
     if (entries[i].type == expected)
       return true;
   }
   return false;
 }
 
 }  // namespace
 
@@ skipping 41 matching lines @@
 
   BoundTestNetLog log;
   LoadTimingInfo load_timing_info;
 
   // Read from the network, and don't use the cache.
   RunTransactionTestAndGetTiming(cache.http_cache(), kSimpleGET_Transaction,
                                  log.bound(), &load_timing_info);
 
   // Check that the NetLog was filled as expected.
   // (We attempted to both Open and Create entries, but both failed).
-  TestNetLog::CapturedEntryList entries;
+  CapturedNetLogEntry::List entries;
   log.GetEntries(&entries);
   FilterLogEntries(&entries);
 
   EXPECT_EQ(6u, entries.size());
   EXPECT_TRUE(
       LogContainsBeginEvent(entries, 0, NetLog::TYPE_HTTP_CACHE_GET_BACKEND));
   EXPECT_TRUE(
       LogContainsEndEvent(entries, 1, NetLog::TYPE_HTTP_CACHE_GET_BACKEND));
   EXPECT_TRUE(
       LogContainsBeginEvent(entries, 2, NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY));
@@ skipping 144 matching lines @@
   MockHttpCache cache;
 
   BoundTestNetLog log;
   LoadTimingInfo load_timing_info;
 
   // Write to the cache.
   RunTransactionTestAndGetTiming(cache.http_cache(), kSimpleGET_Transaction,
                                  log.bound(), &load_timing_info);
 
   // Check that the NetLog was filled as expected.
-  TestNetLog::CapturedEntryList entries;
+  CapturedNetLogEntry::List entries;
   log.GetEntries(&entries);
   FilterLogEntries(&entries);
 
   EXPECT_EQ(8u, entries.size());
   EXPECT_TRUE(
       LogContainsBeginEvent(entries, 0, NetLog::TYPE_HTTP_CACHE_GET_BACKEND));
   EXPECT_TRUE(
       LogContainsEndEvent(entries, 1, NetLog::TYPE_HTTP_CACHE_GET_BACKEND));
   EXPECT_TRUE(
       LogContainsBeginEvent(entries, 2, NetLog::TYPE_HTTP_CACHE_OPEN_ENTRY));
@@ skipping 337 matching lines @@
   transaction.load_flags |= LOAD_BYPASS_CACHE;
 
   BoundTestNetLog log;
   LoadTimingInfo load_timing_info;
 
   // Write to the cache.
   RunTransactionTestAndGetTiming(cache.http_cache(), transaction, log.bound(),
                                  &load_timing_info);
 
   // Check that the NetLog was filled as expected.
-  TestNetLog::CapturedEntryList entries;
+  CapturedNetLogEntry::List entries;
   log.GetEntries(&entries);
   FilterLogEntries(&entries);
 
   EXPECT_EQ(8u, entries.size());
   EXPECT_TRUE(
       LogContainsBeginEvent(entries, 0, NetLog::TYPE_HTTP_CACHE_GET_BACKEND));
   EXPECT_TRUE(
       LogContainsEndEvent(entries, 1, NetLog::TYPE_HTTP_CACHE_GET_BACKEND));
   EXPECT_TRUE(
       LogContainsBeginEvent(entries, 2, NetLog::TYPE_HTTP_CACHE_DOOM_ENTRY));
@@ skipping 6744 matching lines @@
   EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE, second->trans->GetLoadState());
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(LOAD_STATE_IDLE, second->trans->GetLoadState());
   ASSERT_TRUE(second->trans->GetResponseInfo());
   EXPECT_TRUE(second->trans->GetResponseInfo()->headers->HasHeaderValue(
       "Cache-Control", "no-store"));
   ReadAndVerifyTransaction(second->trans.get(), kSimpleGET_Transaction);
 }
 
 }  // namespace net