Add the URLRequest's method and load flags to the NetLog.

chrome/browser/net/passive_log_collector_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/passive_log_collector.h"
 
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/string_util.h"
+#include "net/url_request/url_request_netlog_params.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 typedef PassiveLogCollector::RequestTracker RequestTracker;
 typedef PassiveLogCollector::RequestInfoList RequestInfoList;
 typedef net::NetLog NetLog;
 
 const NetLog::SourceType kSourceType = NetLog::SOURCE_NONE;
 
 PassiveLogCollector::Entry MakeStartLogEntryWithURL(int source_id,
                                                     const std::string& url) {
   return PassiveLogCollector::Entry(
       0,
       NetLog::TYPE_URL_REQUEST_START,
       base::TimeTicks(),
       NetLog::Source(kSourceType, source_id),
       NetLog::PHASE_BEGIN,
-      new net::NetLogStringParameter("url", url));
+      new URLRequestStartEventParameters(GURL(url), "GET", 0));
 }
 
 PassiveLogCollector::Entry MakeStartLogEntry(int source_id) {
   return MakeStartLogEntryWithURL(source_id,
                                   StringPrintf("http://req%d", source_id));
 }
 
 PassiveLogCollector::Entry MakeEndLogEntry(int source_id) {
   return PassiveLogCollector::Entry(
       0,
       NetLog::TYPE_REQUEST_ALIVE,
       base::TimeTicks(),
       NetLog::Source(kSourceType, source_id),
       NetLog::PHASE_END,
       NULL);
 }
 
 void AddStartURLRequestEntries(PassiveLogCollector* collector, uint32 id) {
   collector->OnAddEntry(NetLog::TYPE_REQUEST_ALIVE, base::TimeTicks(),
                         NetLog::Source(NetLog::SOURCE_URL_REQUEST, id),
                         NetLog::PHASE_BEGIN, NULL);
   collector->OnAddEntry(NetLog::TYPE_URL_REQUEST_START, base::TimeTicks(),
                         NetLog::Source(NetLog::SOURCE_URL_REQUEST, id),
-                        NetLog::PHASE_BEGIN, new net::NetLogStringParameter(
-                            "url", StringPrintf("http://req%d", id)));
+                        NetLog::PHASE_BEGIN, new URLRequestStartEventParameters(
+                            GURL(StringPrintf("http://req%d", id)), "GET", 0));
 }
 
 void AddEndURLRequestEntries(PassiveLogCollector* collector, uint32 id) {
   collector->OnAddEntry(NetLog::TYPE_REQUEST_ALIVE, base::TimeTicks(),
                         NetLog::Source(NetLog::SOURCE_URL_REQUEST, id),
                         NetLog::PHASE_END, NULL);
 }
 
 std::string GetStringParam(const PassiveLogCollector::Entry& entry) {
   return static_cast<net::NetLogStringParameter*>(
@@ skipping 11 matching lines @@
 
   tracker.OnAddEntry(MakeStartLogEntry(1));
   tracker.OnAddEntry(MakeStartLogEntry(2));
   tracker.OnAddEntry(MakeStartLogEntry(3));
   tracker.OnAddEntry(MakeStartLogEntry(4));
   tracker.OnAddEntry(MakeStartLogEntry(5));
 
   RequestInfoList live_reqs = tracker.GetLiveRequests();
 
   ASSERT_EQ(5u, live_reqs.size());
-  EXPECT_EQ("http://req1", live_reqs[0].GetURL());
-  EXPECT_EQ("http://req2", live_reqs[1].GetURL());
-  EXPECT_EQ("http://req3", live_reqs[2].GetURL());
-  EXPECT_EQ("http://req4", live_reqs[3].GetURL());
-  EXPECT_EQ("http://req5", live_reqs[4].GetURL());
+  EXPECT_EQ("http://req1/", live_reqs[0].GetURL());
+  EXPECT_EQ("http://req2/", live_reqs[1].GetURL());
+  EXPECT_EQ("http://req3/", live_reqs[2].GetURL());
+  EXPECT_EQ("http://req4/", live_reqs[3].GetURL());
+  EXPECT_EQ("http://req5/", live_reqs[4].GetURL());
 
   tracker.OnAddEntry(MakeEndLogEntry(1));
   tracker.OnAddEntry(MakeEndLogEntry(5));
   tracker.OnAddEntry(MakeEndLogEntry(3));
 
   ASSERT_EQ(3u, tracker.GetRecentlyDeceased().size());
 
   live_reqs = tracker.GetLiveRequests();
 
   ASSERT_EQ(2u, live_reqs.size());
-  EXPECT_EQ("http://req2", live_reqs[0].GetURL());
-  EXPECT_EQ("http://req4", live_reqs[1].GetURL());
+  EXPECT_EQ("http://req2/", live_reqs[0].GetURL());
+  EXPECT_EQ("http://req4/", live_reqs[1].GetURL());
 }
 
 TEST(RequestTrackerTest, GraveyardBounded) {
   RequestTracker tracker(NULL, NULL);
   EXPECT_EQ(0u, tracker.GetLiveRequests().size());
   EXPECT_EQ(0u, tracker.GetRecentlyDeceased().size());
 
   // Add twice as many requests as will fit in the graveyard.
   for (size_t i = 0; i < RequestTracker::kMaxGraveyardSize * 2; ++i) {
     tracker.OnAddEntry(MakeStartLogEntry(i));
     tracker.OnAddEntry(MakeEndLogEntry(i));
   }
 
   // Check that only the last |kMaxGraveyardSize| requests are in-memory.
 
   RequestInfoList recent_reqs = tracker.GetRecentlyDeceased();
 
   ASSERT_EQ(RequestTracker::kMaxGraveyardSize, recent_reqs.size());
 
   for (size_t i = 0; i < RequestTracker::kMaxGraveyardSize; ++i) {
     size_t req_number = i + RequestTracker::kMaxGraveyardSize;
-    std::string url = StringPrintf("http://req%" PRIuS, req_number);
+    std::string url = StringPrintf("http://req%" PRIuS "/", req_number);
     EXPECT_EQ(url, recent_reqs[i].GetURL());
   }
 }
 
 // Check that we exclude "chrome://" URLs from being saved into the recent
 // requests list (graveyard).
 TEST(RequestTrackerTest, GraveyardIsFiltered) {
   RequestTracker tracker(NULL, NULL);
 
   // This will be excluded.
@@ skipping 817 matching lines @@
             GetStringParam(requests[0].entries[4]));
 
   AddEndURLRequestEntries(&log, 20);
   requests = log.url_request_tracker()->GetLiveRequests();
   EXPECT_EQ(0u, requests.size());
   requests = log.url_request_tracker()->GetRecentlyDeceased();
   EXPECT_EQ(2u, requests.size());
   EXPECT_EQ(6u, requests[0].entries.size());
   EXPECT_EQ(6u, requests[1].entries.size());
 }