Address a TODO about renaming RequestInfo --> SourceInfo.

Review URL: http://codereview.chromium.org/2548003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@48881 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 171 insertions, 172 deletions

diff --git a/chrome/browser/net/passive_log_collector.cc b/chrome/browser/net/passive_log_collector.cc
index 4c3e4973..921dfa2 100644
--- a/chrome/browser/net/passive_log_collector.cc
+++ b/chrome/browser/net/passive_log_collector.cc
@@ -17,10 +17,10 @@ namespace {
 // TODO(eroman): Do something with the truncation count.
 
 const size_t kMaxNumEntriesPerLog = 30;
-const size_t kMaxRequestsPerTracker = 200;
+const size_t kMaxSourcesPerTracker = 200;
 
-void AddEntryToRequestInfo(const PassiveLogCollector::Entry& entry,
-                           PassiveLogCollector::RequestInfo* out_info) {
+void AddEntryToSourceInfo(const PassiveLogCollector::Entry& entry,
+                          PassiveLogCollector::SourceInfo* out_info) {
   // Start dropping new entries when the log has gotten too big.
   if (out_info->entries.size() + 1 <= kMaxNumEntriesPerLog) {
     out_info->entries.push_back(entry);
@@ -75,12 +75,12 @@ void PassiveLogCollector::OnAddEntry(
   // Package the parameters into a single struct for convenience.
   Entry entry(num_events_seen_++, type, time, source, phase, params);
 
-  RequestTrackerBase* tracker = GetTrackerForSourceType(entry.source.type);
+  SourceTracker* tracker = GetTrackerForSourceType(entry.source.type);
   if (tracker)
     tracker->OnAddEntry(entry);
 }
 
-PassiveLogCollector::RequestTrackerBase*
+PassiveLogCollector::SourceTracker*
 PassiveLogCollector::GetTrackerForSourceType(
     net::NetLog::SourceType source_type) {
   DCHECK_LE(source_type, static_cast<int>(arraysize(trackers_)));
@@ -105,7 +105,7 @@ void PassiveLogCollector::GetAllCapturedEvents(EntryList* out) const {
   std::sort(out->begin(), out->end(), &SortByOrderComparator);
 }
 
-std::string PassiveLogCollector::RequestInfo::GetURL() const {
+std::string PassiveLogCollector::SourceInfo::GetURL() const {
   // Note: we look at the first *two* entries, since the outer REQUEST_ALIVE
   // doesn't actually contain any data.
   for (size_t i = 0; i < 2 && i < entries.size(); ++i) {
@@ -127,18 +127,18 @@ std::string PassiveLogCollector::RequestInfo::GetURL() const {
 }
 
 //----------------------------------------------------------------------------
-// RequestTrackerBase
+// SourceTracker
 //----------------------------------------------------------------------------
 
-PassiveLogCollector::RequestTrackerBase::RequestTrackerBase(
+PassiveLogCollector::SourceTracker::SourceTracker(
     size_t max_graveyard_size, PassiveLogCollector* parent)
     : max_graveyard_size_(max_graveyard_size), parent_(parent) {
 }
 
-PassiveLogCollector::RequestTrackerBase::~RequestTrackerBase() {}
+PassiveLogCollector::SourceTracker::~SourceTracker() {}
 
-void PassiveLogCollector::RequestTrackerBase::OnAddEntry(const Entry& entry) {
-  RequestInfo& info = requests_[entry.source.id];
+void PassiveLogCollector::SourceTracker::OnAddEntry(const Entry& entry) {
+  SourceInfo& info = sources_[entry.source.id];
   info.source_id = entry.source.id;  // In case this is a new entry.
   Action result = DoAddEntry(entry, &info);
 
@@ -153,7 +153,7 @@ void PassiveLogCollector::RequestTrackerBase::OnAddEntry(const Entry& entry) {
           AddToDeletionQueue(info.source_id);
           break;
         case ACTION_DELETE:
-          DeleteRequestInfo(info.source_id);
+          DeleteSourceInfo(info.source_id);
           break;
         default:
           NOTREACHED();
@@ -162,7 +162,7 @@ void PassiveLogCollector::RequestTrackerBase::OnAddEntry(const Entry& entry) {
     }
   }
 
-  if (requests_.size() > kMaxRequestsPerTracker) {
+  if (sources_.size() > kMaxSourcesPerTracker) {
     // This is a safety net in case something went wrong, to avoid continually
     // growing memory.
     LOG(WARNING) << "The passive log data has grown larger "
@@ -171,71 +171,71 @@ void PassiveLogCollector::RequestTrackerBase::OnAddEntry(const Entry& entry) {
   }
 }
 
-void PassiveLogCollector::RequestTrackerBase::DeleteRequestInfo(
+void PassiveLogCollector::SourceTracker::DeleteSourceInfo(
     uint32 source_id) {
-  SourceIDToInfoMap::iterator it = requests_.find(source_id);
-  DCHECK(it != requests_.end());
-  // The request should not be in the deletion queue.
+  SourceIDToInfoMap::iterator it = sources_.find(source_id);
+  DCHECK(it != sources_.end());
+  // The source should not be in the deletion queue.
   DCHECK(std::find(deletion_queue_.begin(), deletion_queue_.end(),
                    source_id) == deletion_queue_.end());
   ReleaseAllReferencesToDependencies(&(it->second));
-  requests_.erase(it);
+  sources_.erase(it);
 }
 
-void PassiveLogCollector::RequestTrackerBase::Clear() {
+void PassiveLogCollector::SourceTracker::Clear() {
   deletion_queue_.clear();
 
   // Release all references held to dependent sources.
-  for (SourceIDToInfoMap::iterator it = requests_.begin();
-       it != requests_.end();
+  for (SourceIDToInfoMap::iterator it = sources_.begin();
+       it != sources_.end();
        ++it) {
     ReleaseAllReferencesToDependencies(&(it->second));
   }
-  requests_.clear();
+  sources_.clear();
 }
 
-void PassiveLogCollector::RequestTrackerBase::AppendAllEntries(
+void PassiveLogCollector::SourceTracker::AppendAllEntries(
     EntryList* out) const {
   // Append all of the entries for each of the sources.
-  for (SourceIDToInfoMap::const_iterator it = requests_.begin();
-       it != requests_.end();
+  for (SourceIDToInfoMap::const_iterator it = sources_.begin();
+       it != sources_.end();
        ++it) {
-    const RequestInfo& info = it->second;
+    const SourceInfo& info = it->second;
     out->insert(out->end(), info.entries.begin(), info.entries.end());
   }
 }
 
-void PassiveLogCollector::RequestTrackerBase::AddToDeletionQueue(
+void PassiveLogCollector::SourceTracker::AddToDeletionQueue(
     uint32 source_id) {
-  DCHECK(requests_.find(source_id) != requests_.end());
-  DCHECK(!requests_.find(source_id)->second.is_alive);
-  DCHECK_GE(requests_.find(source_id)->second.reference_count, 0);
+  DCHECK(sources_.find(source_id) != sources_.end());
+  DCHECK(!sources_.find(source_id)->second.is_alive);
+  DCHECK_GE(sources_.find(source_id)->second.reference_count, 0);
   DCHECK_LE(deletion_queue_.size(), max_graveyard_size_);
 
   deletion_queue_.push_back(source_id);
 
   // After the deletion queue has reached its maximum size, start
-  // deleting requests in FIFO order.
+  // deleting sources in FIFO order.
   if (deletion_queue_.size() > max_graveyard_size_) {
     uint32 oldest = deletion_queue_.front();
     deletion_queue_.pop_front();
-    DeleteRequestInfo(oldest);
+    DeleteSourceInfo(oldest);
   }
 }
 
-void PassiveLogCollector::RequestTrackerBase::AdjustReferenceCountForSource(
+void PassiveLogCollector::SourceTracker::AdjustReferenceCountForSource(
     int offset, uint32 source_id) {
   DCHECK(offset == -1 || offset == 1) << "invalid offset: " << offset;
 
   // In general it is invalid to call AdjustReferenceCountForSource() on
   // source that doesn't exist. However, it is possible that if
-  // RequestTrackerBase::Clear() was previously called this can happen.
+  // SourceTracker::Clear() was previously called this can happen.
   // TODO(eroman): Add a unit-test that exercises this case.
-  SourceIDToInfoMap::iterator it = requests_.find(source_id);
-  if (it == requests_.end())
+  SourceIDToInfoMap::iterator it = sources_.find(source_id);
+  if (it == sources_.end())
     return;
 
-  RequestInfo& info = it->second;
+  SourceInfo& info = it->second;
   DCHECK_GE(info.reference_count, 0);
   DCHECK_GE(info.reference_count + offset, 0);
   info.reference_count += offset;
@@ -250,18 +250,18 @@ void PassiveLogCollector::RequestTrackerBase::AdjustReferenceCountForSource(
       DCHECK(it != deletion_queue_.end());
       deletion_queue_.erase(it);
     } else if (info.reference_count == 0) {
-      // If we just released the final reference to a dead request, go ahead
+      // If we just released the final reference to a dead source, go ahead
       // and delete it right away.
-      DeleteRequestInfo(source_id);
+      DeleteSourceInfo(source_id);
     }
   }
 }
 
-void PassiveLogCollector::RequestTrackerBase::AddReferenceToSourceDependency(
-    const net::NetLog::Source& source, RequestInfo* info) {
+void PassiveLogCollector::SourceTracker::AddReferenceToSourceDependency(
+    const net::NetLog::Source& source, SourceInfo* info) {
   // Find the tracker which should be holding |source|.
   DCHECK(parent_);
-  RequestTrackerBase* tracker =
+  SourceTracker* tracker =
       parent_->GetTrackerForSourceType(source.type);
   DCHECK(tracker);
 
@@ -273,8 +273,8 @@ void PassiveLogCollector::RequestTrackerBase::AddReferenceToSourceDependency(
 }
 
 void
-PassiveLogCollector::RequestTrackerBase::ReleaseAllReferencesToDependencies(
-    RequestInfo* info) {
+PassiveLogCollector::SourceTracker::ReleaseAllReferencesToDependencies(
+    SourceInfo* info) {
   // Release all references |info| was holding to dependent sources.
   for (SourceDependencyList::const_iterator it = info->dependencies.begin();
        it != info->dependencies.end(); ++it) {
@@ -282,7 +282,7 @@ PassiveLogCollector::RequestTrackerBase::ReleaseAllReferencesToDependencies(
 
     // Find the tracker which should be holding |source|.
     DCHECK(parent_);
-    RequestTrackerBase* tracker =
+    SourceTracker* tracker =
         parent_->GetTrackerForSourceType(source.type);
     DCHECK(tracker);
 
@@ -301,13 +301,13 @@ const size_t PassiveLogCollector::ConnectJobTracker::kMaxGraveyardSize = 15;
 
 PassiveLogCollector::ConnectJobTracker::ConnectJobTracker(
     PassiveLogCollector* parent)
-    : RequestTrackerBase(kMaxGraveyardSize, parent) {
+    : SourceTracker(kMaxGraveyardSize, parent) {
 }
 
-PassiveLogCollector::RequestTrackerBase::Action
+PassiveLogCollector::SourceTracker::Action
 PassiveLogCollector::ConnectJobTracker::DoAddEntry(const Entry& entry,
-                                                   RequestInfo* out_info) {
-  AddEntryToRequestInfo(entry, out_info);
+                                                   SourceInfo* out_info) {
+  AddEntryToSourceInfo(entry, out_info);
 
   if (entry.type == net::NetLog::TYPE_CONNECT_JOB_SET_SOCKET) {
     const net::NetLog::Source& source_dependency =
@@ -315,7 +315,7 @@ PassiveLogCollector::ConnectJobTracker::DoAddEntry(const Entry& entry,
     AddReferenceToSourceDependency(source_dependency, out_info);
   }
 
-  // If this is the end of the connect job, move the request to the graveyard.
+  // If this is the end of the connect job, move the source to the graveyard.
   if (entry.type == net::NetLog::TYPE_SOCKET_POOL_CONNECT_JOB &&
       entry.phase == net::NetLog::PHASE_END) {
     return ACTION_MOVE_TO_GRAVEYARD;
@@ -331,12 +331,12 @@ PassiveLogCollector::ConnectJobTracker::DoAddEntry(const Entry& entry,
 const size_t PassiveLogCollector::SocketTracker::kMaxGraveyardSize = 15;
 
 PassiveLogCollector::SocketTracker::SocketTracker()
-    : RequestTrackerBase(kMaxGraveyardSize, NULL) {
+    : SourceTracker(kMaxGraveyardSize, NULL) {
 }
 
-PassiveLogCollector::RequestTrackerBase::Action
+PassiveLogCollector::SourceTracker::Action
 PassiveLogCollector::SocketTracker::DoAddEntry(const Entry& entry,
-                                               RequestInfo* out_info) {
+                                               SourceInfo* out_info) {
   // TODO(eroman): aggregate the byte counts once truncation starts to happen,
   //               to summarize transaction read/writes for each SOCKET_IN_USE
   //               section.
@@ -345,7 +345,7 @@ PassiveLogCollector::SocketTracker::DoAddEntry(const Entry& entry,
     return ACTION_NONE;
   }
 
-  AddEntryToRequestInfo(entry, out_info);
+  AddEntryToSourceInfo(entry, out_info);
 
   if (entry.type == net::NetLog::TYPE_SOCKET_ALIVE &&
       entry.phase == net::NetLog::PHASE_END) {
@@ -362,12 +362,12 @@ PassiveLogCollector::SocketTracker::DoAddEntry(const Entry& entry,
 const size_t PassiveLogCollector::RequestTracker::kMaxGraveyardSize = 25;
 
 PassiveLogCollector::RequestTracker::RequestTracker(PassiveLogCollector* parent)
-    : RequestTrackerBase(kMaxGraveyardSize, parent) {
+    : SourceTracker(kMaxGraveyardSize, parent) {
 }
 
-PassiveLogCollector::RequestTrackerBase::Action
+PassiveLogCollector::SourceTracker::Action
 PassiveLogCollector::RequestTracker::DoAddEntry(const Entry& entry,
-                                                RequestInfo* out_info) {
+                                                SourceInfo* out_info) {
   if (entry.type == net::NetLog::TYPE_SOCKET_POOL_BOUND_TO_CONNECT_JOB ||
       entry.type == net::NetLog::TYPE_SOCKET_POOL_BOUND_TO_SOCKET) {
     const net::NetLog::Source& source_dependency =
@@ -375,7 +375,7 @@ PassiveLogCollector::RequestTracker::DoAddEntry(const Entry& entry,
     AddReferenceToSourceDependency(source_dependency, out_info);
   }
 
-  AddEntryToRequestInfo(entry, out_info);
+  AddEntryToSourceInfo(entry, out_info);
 
   // If the request has ended, move it to the graveyard.
   if (entry.type == net::NetLog::TYPE_REQUEST_ALIVE &&
@@ -399,13 +399,13 @@ const size_t PassiveLogCollector::InitProxyResolverTracker::kMaxGraveyardSize =
     3;
 
 PassiveLogCollector::InitProxyResolverTracker::InitProxyResolverTracker()
-    : RequestTrackerBase(kMaxGraveyardSize, NULL) {
+    : SourceTracker(kMaxGraveyardSize, NULL) {
 }
 
-PassiveLogCollector::RequestTrackerBase::Action
+PassiveLogCollector::SourceTracker::Action
 PassiveLogCollector::InitProxyResolverTracker::DoAddEntry(
-    const Entry& entry, RequestInfo* out_info) {
-  AddEntryToRequestInfo(entry, out_info);
+    const Entry& entry, SourceInfo* out_info) {
+  AddEntryToSourceInfo(entry, out_info);
   if (entry.type == net::NetLog::TYPE_INIT_PROXY_RESOLVER &&
       entry.phase == net::NetLog::PHASE_END) {
     return ACTION_MOVE_TO_GRAVEYARD;
@@ -421,13 +421,13 @@ PassiveLogCollector::InitProxyResolverTracker::DoAddEntry(
 const size_t PassiveLogCollector::SpdySessionTracker::kMaxGraveyardSize = 10;
 
 PassiveLogCollector::SpdySessionTracker::SpdySessionTracker()
-    : RequestTrackerBase(kMaxGraveyardSize, NULL) {
+    : SourceTracker(kMaxGraveyardSize, NULL) {
 }
 
-PassiveLogCollector::RequestTrackerBase::Action
+PassiveLogCollector::SourceTracker::Action
 PassiveLogCollector::SpdySessionTracker::DoAddEntry(const Entry& entry,
-                                                    RequestInfo* out_info) {
-  AddEntryToRequestInfo(entry, out_info);
+                                                    SourceInfo* out_info) {
+  AddEntryToSourceInfo(entry, out_info);
   if (entry.type == net::NetLog::TYPE_SPDY_SESSION &&
       entry.phase == net::NetLog::PHASE_END) {
     return ACTION_MOVE_TO_GRAVEYARD;
diff --git a/chrome/browser/net/passive_log_collector.h b/chrome/browser/net/passive_log_collector.h
index a514428..7fcc281 100644
--- a/chrome/browser/net/passive_log_collector.h
+++ b/chrome/browser/net/passive_log_collector.h
@@ -17,7 +17,7 @@
 #include "net/base/net_log.h"
 
 // PassiveLogCollector watches the NetLog event stream, and saves the network
-// event for recent requests, in a circular buffer.
+// events for recent requests, in a circular buffer.
 //
 // This is done so that when a network problem is encountered (performance
 // problem, or error), about:net-internals can be opened shortly after the
@@ -29,8 +29,8 @@
 // about:net-internals is open).
 //
 // The data captured by PassiveLogCollector is grouped by NetLog::Source, into
-// a RequestInfo structure. These in turn are grouped by NetLog::SourceType, and
-// owned by a RequestTrackerBase instance for the specific source type.
+// a SourceInfo structure. These in turn are grouped by NetLog::SourceType, and
+// owned by a SourceTracker instance for the specific source type.
 class PassiveLogCollector : public ChromeNetLog::Observer {
  public:
   // This structure encapsulates all of the parameters of a captured event,
@@ -58,9 +58,8 @@ class PassiveLogCollector : public ChromeNetLog::Observer {
   typedef std::vector<Entry> EntryList;
   typedef std::vector<net::NetLog::Source> SourceDependencyList;
 
-  // TODO(eroman): Rename to SourceInfo.
-  struct RequestInfo {
-    RequestInfo()
+  struct SourceInfo {
+    SourceInfo()
         : source_id(net::NetLog::Source::kInvalidId),
           num_entries_truncated(0), reference_count(0), is_alive(true) {}
 
@@ -74,7 +73,7 @@ class PassiveLogCollector : public ChromeNetLog::Observer {
     size_t num_entries_truncated;
 
     // List of other sources which contain information relevant to this
-    // request (for example, a url request might depend on the log items
+    // source (for example, a url request might depend on the log items
     // for a connect job and for a socket that were bound to it.)
     SourceDependencyList dependencies;
 
@@ -83,21 +82,21 @@ class PassiveLogCollector : public ChromeNetLog::Observer {
     // can be deleted normally.
     int reference_count;
 
-    // |is_alive| is set to false once the request has been added to the
+    // |is_alive| is set to false once the source has been added to the
     // tracker's graveyard (it may still be kept around due to a non-zero
     // reference_count, but it is still considered "dead").
     bool is_alive;
   };
 
-  typedef std::vector<RequestInfo> RequestInfoList;
+  typedef std::vector<SourceInfo> SourceInfoList;
 
   // This class stores and manages the passively logged information for
   // URLRequests/SocketStreams/ConnectJobs.
-  class RequestTrackerBase {
+  class SourceTracker {
    public:
-    RequestTrackerBase(size_t max_graveyard_size, PassiveLogCollector* parent);
+    SourceTracker(size_t max_graveyard_size, PassiveLogCollector* parent);
 
-    virtual ~RequestTrackerBase();
+    virtual ~SourceTracker();
 
     void OnAddEntry(const Entry& entry);
 
@@ -109,11 +108,11 @@ class PassiveLogCollector : public ChromeNetLog::Observer {
 
 #ifdef UNIT_TEST
     // Helper used to inspect the current state by unit-tests.
-    // Retuns a copy of the requests held by the tracker.
-    RequestInfoList GetAllDeadOrAliveRequests(bool is_alive) const {
-      RequestInfoList result;
-      for (SourceIDToInfoMap::const_iterator it = requests_.begin();
-           it != requests_.end(); ++it) {
+    // Retuns a copy of the source infos held by the tracker.
+    SourceInfoList GetAllDeadOrAliveSources(bool is_alive) const {
+      SourceInfoList result;
+      for (SourceIDToInfoMap::const_iterator it = sources_.begin();
+           it != sources_.end(); ++it) {
         if (it->second.is_alive == is_alive)
           result.push_back(it->second);
       }
@@ -131,19 +130,19 @@ class PassiveLogCollector : public ChromeNetLog::Observer {
     // Makes |info| hold a reference to |source|. This way |source| will be
     // kept alive at least as long as |info|.
     void AddReferenceToSourceDependency(const net::NetLog::Source& source,
-                                        RequestInfo* info);
+                                        SourceInfo* info);
 
    private:
-    typedef base::hash_map<uint32, RequestInfo> SourceIDToInfoMap;
+    typedef base::hash_map<uint32, SourceInfo> SourceIDToInfoMap;
     typedef std::deque<uint32> DeletionQueue;
 
     // Updates |out_info| with the information from |entry|. Returns an action
     // to perform for this map entry on completion.
-    virtual Action DoAddEntry(const Entry& entry, RequestInfo* out_info) = 0;
+    virtual Action DoAddEntry(const Entry& entry, SourceInfo* out_info) = 0;
 
-    // Removes |source_id| from |requests_|. This also releases any references
+    // Removes |source_id| from |sources_|. This also releases any references
     // to dependencies held by this source.
-    void DeleteRequestInfo(uint32 source_id);
+    void DeleteSourceInfo(uint32 source_id);
 
     // Adds |source_id| to the FIFO queue (graveyard) for deletion.
     void AddToDeletionQueue(uint32 source_id);
@@ -153,89 +152,89 @@ class PassiveLogCollector : public ChromeNetLog::Observer {
     void AdjustReferenceCountForSource(int offset, uint32 source_id);
 
     // Releases all the references to sources held by |info|.
-    void ReleaseAllReferencesToDependencies(RequestInfo* info);
+    void ReleaseAllReferencesToDependencies(SourceInfo* info);
 
-    // This map contains all of the requests being tracked by this tracker.
-    // (It includes both the "live" requests, and the "dead" ones.)
-    SourceIDToInfoMap requests_;
+    // This map contains all of the sources being tracked by this tracker.
+    // (It includes both the "live" sources, and the "dead" ones.)
+    SourceIDToInfoMap sources_;
 
     size_t max_graveyard_size_;
 
-    // FIFO queue for entries in |requests_| that are no longer alive, and
+    // FIFO queue for entries in |sources_| that are no longer alive, and
     // can be deleted. This buffer is also called "graveyard" elsewhere. We
-    // queue requests for deletion so they can persist a bit longer.
+    // queue sources for deletion so they can persist a bit longer.
     DeletionQueue deletion_queue_;
 
     PassiveLogCollector* parent_;
 
-    DISALLOW_COPY_AND_ASSIGN(RequestTrackerBase);
+    DISALLOW_COPY_AND_ASSIGN(SourceTracker);
   };
 
-  // Specialization of RequestTrackerBase for handling ConnectJobs.
-  class ConnectJobTracker : public RequestTrackerBase {
+  // Specialization of SourceTracker for handling ConnectJobs.
+  class ConnectJobTracker : public SourceTracker {
    public:
     static const size_t kMaxGraveyardSize;
 
     explicit ConnectJobTracker(PassiveLogCollector* parent);
 
    protected:
-    virtual Action DoAddEntry(const Entry& entry, RequestInfo* out_info);
+    virtual Action DoAddEntry(const Entry& entry, SourceInfo* out_info);
    private:
     DISALLOW_COPY_AND_ASSIGN(ConnectJobTracker);
   };
 
-  // Specialization of RequestTrackerBase for handling Sockets.
-  class SocketTracker : public RequestTrackerBase {
+  // Specialization of SourceTracker for handling Sockets.
+  class SocketTracker : public SourceTracker {
    public:
     static const size_t kMaxGraveyardSize;
 
     SocketTracker();
 
    protected:
-    virtual Action DoAddEntry(const Entry& entry, RequestInfo* out_info);
+    virtual Action DoAddEntry(const Entry& entry, SourceInfo* out_info);
 
    private:
     DISALLOW_COPY_AND_ASSIGN(SocketTracker);
   };
 
-  // Specialization of RequestTrackerBase for handling URLRequest/SocketStream.
-  class RequestTracker : public RequestTrackerBase {
+  // Specialization of SourceTracker for handling URLRequest/SocketStream.
+  class RequestTracker : public SourceTracker {
    public:
     static const size_t kMaxGraveyardSize;
 
     explicit RequestTracker(PassiveLogCollector* parent);
 
    protected:
-    virtual Action DoAddEntry(const Entry& entry, RequestInfo* out_info);
+    virtual Action DoAddEntry(const Entry& entry, SourceInfo* out_info);
 
    private:
     DISALLOW_COPY_AND_ASSIGN(RequestTracker);
   };
 
-  // Specialization of RequestTrackerBase for handling
+  // Specialization of SourceTracker for handling
   // SOURCE_INIT_PROXY_RESOLVER.
-  class InitProxyResolverTracker : public RequestTrackerBase {
+  class InitProxyResolverTracker : public SourceTracker {
    public:
     static const size_t kMaxGraveyardSize;
 
     InitProxyResolverTracker();
 
    protected:
-    virtual Action DoAddEntry(const Entry& entry, RequestInfo* out_info);
+    virtual Action DoAddEntry(const Entry& entry, SourceInfo* out_info);
 
    private:
     DISALLOW_COPY_AND_ASSIGN(InitProxyResolverTracker);
   };
 
   // Tracks the log entries for the last seen SOURCE_SPDY_SESSION.
-  class SpdySessionTracker : public RequestTrackerBase {
+  class SpdySessionTracker : public SourceTracker {
    public:
     static const size_t kMaxGraveyardSize;
 
     SpdySessionTracker();
 
    protected:
-    virtual Action DoAddEntry(const Entry& entry, RequestInfo* out_info);
+    virtual Action DoAddEntry(const Entry& entry, SourceInfo* out_info);
 
    private:
     DISALLOW_COPY_AND_ASSIGN(SpdySessionTracker);
@@ -252,7 +251,7 @@ class PassiveLogCollector : public ChromeNetLog::Observer {
                           net::NetLog::EventParameters* params);
 
   // Returns the tracker to use for sources of type |source_type|, or NULL.
-  RequestTrackerBase* GetTrackerForSourceType(
+  SourceTracker* GetTrackerForSourceType(
       net::NetLog::SourceType source_type);
 
   // Clears all of the passively logged data.
@@ -276,7 +275,7 @@ class PassiveLogCollector : public ChromeNetLog::Observer {
   // This array maps each NetLog::SourceType to one of the tracker instances
   // defined above. Use of this array avoid duplicating the list of trackers
   // elsewhere.
-  RequestTrackerBase* trackers_[net::NetLog::SOURCE_COUNT];
+  SourceTracker* trackers_[net::NetLog::SOURCE_COUNT];
 
   // The count of how many events have flowed through this log. Used to set the
   // "order" field on captured events.
diff --git a/chrome/browser/net/passive_log_collector_unittest.cc b/chrome/browser/net/passive_log_collector_unittest.cc
index 3e0894c..aab7886 100644
--- a/chrome/browser/net/passive_log_collector_unittest.cc
+++ b/chrome/browser/net/passive_log_collector_unittest.cc
@@ -13,7 +13,7 @@
 namespace {
 
 typedef PassiveLogCollector::RequestTracker RequestTracker;
-typedef PassiveLogCollector::RequestInfoList RequestInfoList;
+typedef PassiveLogCollector::SourceInfoList SourceInfoList;
 typedef PassiveLogCollector::SocketTracker SocketTracker;
 using net::NetLog;
 
@@ -66,21 +66,21 @@ std::string GetStringParam(const PassiveLogCollector::Entry& entry) {
       entry.params.get())->value();
 }
 
-bool OrderBySourceID(const PassiveLogCollector::RequestInfo& a,
-                     const PassiveLogCollector::RequestInfo& b) {
+bool OrderBySourceID(const PassiveLogCollector::SourceInfo& a,
+                     const PassiveLogCollector::SourceInfo& b) {
   return a.source_id < b.source_id;
 }
 
-RequestInfoList GetLiveRequests(
-    const PassiveLogCollector::RequestTrackerBase& tracker) {
-  RequestInfoList result = tracker.GetAllDeadOrAliveRequests(true);
+SourceInfoList GetLiveSources(
+    const PassiveLogCollector::SourceTracker& tracker) {
+  SourceInfoList result = tracker.GetAllDeadOrAliveSources(true);
   std::sort(result.begin(), result.end(), &OrderBySourceID);
   return result;
 }
 
-RequestInfoList GetDeadRequests(
-    const PassiveLogCollector::RequestTrackerBase& tracker) {
-  RequestInfoList result = tracker.GetAllDeadOrAliveRequests(false);
+SourceInfoList GetDeadSources(
+    const PassiveLogCollector::SourceTracker& tracker) {
+  SourceInfoList result = tracker.GetAllDeadOrAliveSources(false);
   std::sort(result.begin(), result.end(), &OrderBySourceID);
   return result;
 }
@@ -91,8 +91,8 @@ static const int kMaxNumLoadLogEntries = 1;
 
 TEST(RequestTrackerTest, BasicBounded) {
   RequestTracker tracker(NULL);
-  EXPECT_EQ(0u, GetLiveRequests(tracker).size());
-  EXPECT_EQ(0u, GetDeadRequests(tracker).size());
+  EXPECT_EQ(0u, GetLiveSources(tracker).size());
+  EXPECT_EQ(0u, GetDeadSources(tracker).size());
 
   tracker.OnAddEntry(MakeStartLogEntry(1));
   tracker.OnAddEntry(MakeStartLogEntry(2));
@@ -100,7 +100,7 @@ TEST(RequestTrackerTest, BasicBounded) {
   tracker.OnAddEntry(MakeStartLogEntry(4));
   tracker.OnAddEntry(MakeStartLogEntry(5));
 
-  RequestInfoList live_reqs = GetLiveRequests(tracker);
+  SourceInfoList live_reqs = GetLiveSources(tracker);
 
   ASSERT_EQ(5u, live_reqs.size());
   EXPECT_EQ("http://req1/", live_reqs[0].GetURL());
@@ -113,9 +113,9 @@ TEST(RequestTrackerTest, BasicBounded) {
   tracker.OnAddEntry(MakeEndLogEntry(5));
   tracker.OnAddEntry(MakeEndLogEntry(3));
 
-  ASSERT_EQ(3u, GetDeadRequests(tracker).size());
+  ASSERT_EQ(3u, GetDeadSources(tracker).size());
 
-  live_reqs = GetLiveRequests(tracker);
+  live_reqs = GetLiveSources(tracker);
 
   ASSERT_EQ(2u, live_reqs.size());
   EXPECT_EQ("http://req2/", live_reqs[0].GetURL());
@@ -124,8 +124,8 @@ TEST(RequestTrackerTest, BasicBounded) {
 
 TEST(RequestTrackerTest, GraveyardBounded) {
   RequestTracker tracker(NULL);
-  EXPECT_EQ(0u, GetLiveRequests(tracker).size());
-  EXPECT_EQ(0u, GetDeadRequests(tracker).size());
+  EXPECT_EQ(0u, GetLiveSources(tracker).size());
+  EXPECT_EQ(0u, GetDeadSources(tracker).size());
 
   // Add twice as many requests as will fit in the graveyard.
   for (size_t i = 0; i < RequestTracker::kMaxGraveyardSize * 2; ++i) {
@@ -133,18 +133,18 @@ TEST(RequestTrackerTest, GraveyardBounded) {
     tracker.OnAddEntry(MakeEndLogEntry(i));
   }
 
-  EXPECT_EQ(0u, GetLiveRequests(tracker).size());
+  EXPECT_EQ(0u, GetLiveSources(tracker).size());
 
   // Check that only the last |kMaxGraveyardSize| requests are in-memory.
 
-  RequestInfoList recent_reqs = GetDeadRequests(tracker);
+  SourceInfoList recent = GetDeadSources(tracker);
 
-  ASSERT_EQ(RequestTracker::kMaxGraveyardSize, recent_reqs.size());
+  ASSERT_EQ(RequestTracker::kMaxGraveyardSize, recent.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);
-    EXPECT_EQ(url, recent_reqs[i].GetURL());
+    EXPECT_EQ(url, recent[i].GetURL());
   }
 }
 
@@ -168,15 +168,15 @@ TEST(RequestTrackerTest, GraveyardIsFiltered) {
   tracker.OnAddEntry(MakeStartLogEntryWithURL(3, url3));
   tracker.OnAddEntry(MakeEndLogEntry(3));
 
-  ASSERT_EQ(2u, GetDeadRequests(tracker).size());
-  EXPECT_EQ(url2, GetDeadRequests(tracker)[0].GetURL());
-  EXPECT_EQ(url3, GetDeadRequests(tracker)[1].GetURL());
+  ASSERT_EQ(2u, GetDeadSources(tracker).size());
+  EXPECT_EQ(url2, GetDeadSources(tracker)[0].GetURL());
+  EXPECT_EQ(url3, GetDeadSources(tracker)[1].GetURL());
 }
 
 TEST(SpdySessionTracker, MovesToGraveyard) {
   PassiveLogCollector::SpdySessionTracker tracker;
-  EXPECT_EQ(0u, GetLiveRequests(tracker).size());
-  EXPECT_EQ(0u, GetDeadRequests(tracker).size());
+  EXPECT_EQ(0u, GetLiveSources(tracker).size());
+  EXPECT_EQ(0u, GetDeadSources(tracker).size());
 
   PassiveLogCollector::Entry begin(
       0u,
@@ -187,8 +187,8 @@ TEST(SpdySessionTracker, MovesToGraveyard) {
       NULL);
 
   tracker.OnAddEntry(begin);
-  EXPECT_EQ(1u, GetLiveRequests(tracker).size());
-  EXPECT_EQ(0u, GetDeadRequests(tracker).size());
+  EXPECT_EQ(1u, GetLiveSources(tracker).size());
+  EXPECT_EQ(0u, GetDeadSources(tracker).size());
 
   PassiveLogCollector::Entry end(
       0u,
@@ -199,8 +199,8 @@ TEST(SpdySessionTracker, MovesToGraveyard) {
       NULL);
 
   tracker.OnAddEntry(end);
-  EXPECT_EQ(0u, GetLiveRequests(tracker).size());
-  EXPECT_EQ(1u, GetDeadRequests(tracker).size());
+  EXPECT_EQ(0u, GetLiveSources(tracker).size());
+  EXPECT_EQ(1u, GetDeadSources(tracker).size());
 }
 
 // Test that when a SOURCE_SOCKET is connected to a SOURCE_URL_REQUEST
@@ -210,8 +210,8 @@ TEST(SpdySessionTracker, MovesToGraveyard) {
 TEST(PassiveLogCollectorTest, HoldReferenceToDependentSource) {
   PassiveLogCollector log;
 
-  EXPECT_EQ(0u, GetLiveRequests(log.url_request_tracker_).size());
-  EXPECT_EQ(0u, GetLiveRequests(log.socket_tracker_).size());
+  EXPECT_EQ(0u, GetLiveSources(log.url_request_tracker_).size());
+  EXPECT_EQ(0u, GetLiveSources(log.socket_tracker_).size());
 
   uint32 next_id = 0;
   NetLog::Source socket_source(NetLog::SOURCE_SOCKET, next_id++);
@@ -224,8 +224,8 @@ TEST(PassiveLogCollectorTest, HoldReferenceToDependentSource) {
                  NetLog::PHASE_BEGIN,
                  NULL);
 
-  EXPECT_EQ(0u, GetLiveRequests(log.url_request_tracker_).size());
-  EXPECT_EQ(1u, GetLiveRequests(log.socket_tracker_).size());
+  EXPECT_EQ(0u, GetLiveSources(log.url_request_tracker_).size());
+  EXPECT_EQ(1u, GetLiveSources(log.socket_tracker_).size());
 
   // Start a SOURCE_URL_REQUEST.
   log.OnAddEntry(NetLog::TYPE_REQUEST_ALIVE,
@@ -236,17 +236,17 @@ TEST(PassiveLogCollectorTest, HoldReferenceToDependentSource) {
 
   // Check that there is no association between the SOURCE_URL_REQUEST and the
   // SOURCE_SOCKET yet.
-  ASSERT_EQ(1u, GetLiveRequests(log.url_request_tracker_).size());
+  ASSERT_EQ(1u, GetLiveSources(log.url_request_tracker_).size());
   {
-    PassiveLogCollector::RequestInfo info =
-        GetLiveRequests(log.url_request_tracker_)[0];
+    PassiveLogCollector::SourceInfo info =
+        GetLiveSources(log.url_request_tracker_)[0];
     EXPECT_EQ(0, info.reference_count);
     EXPECT_EQ(0u, info.dependencies.size());
   }
-  ASSERT_EQ(1u, GetLiveRequests(log.socket_tracker_).size());
+  ASSERT_EQ(1u, GetLiveSources(log.socket_tracker_).size());
   {
-    PassiveLogCollector::RequestInfo info =
-        GetLiveRequests(log.socket_tracker_)[0];
+    PassiveLogCollector::SourceInfo info =
+        GetLiveSources(log.socket_tracker_)[0];
     EXPECT_EQ(0, info.reference_count);
     EXPECT_EQ(0u, info.dependencies.size());
   }
@@ -260,18 +260,18 @@ TEST(PassiveLogCollectorTest, HoldReferenceToDependentSource) {
 
   // Check that an associate was made -- the SOURCE_URL_REQUEST should have
   // added a reference to the SOURCE_SOCKET.
-  ASSERT_EQ(1u, GetLiveRequests(log.url_request_tracker_).size());
+  ASSERT_EQ(1u, GetLiveSources(log.url_request_tracker_).size());
   {
-    PassiveLogCollector::RequestInfo info =
-        GetLiveRequests(log.url_request_tracker_)[0];
+    PassiveLogCollector::SourceInfo info =
+        GetLiveSources(log.url_request_tracker_)[0];
     EXPECT_EQ(0, info.reference_count);
     EXPECT_EQ(1u, info.dependencies.size());
     EXPECT_EQ(socket_source.id, info.dependencies[0].id);
   }
-  ASSERT_EQ(1u, GetLiveRequests(log.socket_tracker_).size());
+  ASSERT_EQ(1u, GetLiveSources(log.socket_tracker_).size());
   {
-    PassiveLogCollector::RequestInfo info =
-        GetLiveRequests(log.socket_tracker_)[0];
+    PassiveLogCollector::SourceInfo info =
+        GetLiveSources(log.socket_tracker_)[0];
     EXPECT_EQ(1, info.reference_count);
     EXPECT_EQ(0u, info.dependencies.size());
   }
@@ -293,20 +293,20 @@ TEST(PassiveLogCollectorTest, HoldReferenceToDependentSource) {
 
   // Verify that both sources are in fact dead, and that |source_url_request|
   // still holds a reference to |source_socket|.
-  ASSERT_EQ(0u, GetLiveRequests(log.url_request_tracker_).size());
-  ASSERT_EQ(1u, GetDeadRequests(log.url_request_tracker_).size());
+  ASSERT_EQ(0u, GetLiveSources(log.url_request_tracker_).size());
+  ASSERT_EQ(1u, GetDeadSources(log.url_request_tracker_).size());
   {
-    PassiveLogCollector::RequestInfo info =
-        GetDeadRequests(log.url_request_tracker_)[0];
+    PassiveLogCollector::SourceInfo info =
+        GetDeadSources(log.url_request_tracker_)[0];
     EXPECT_EQ(0, info.reference_count);
     EXPECT_EQ(1u, info.dependencies.size());
     EXPECT_EQ(socket_source.id, info.dependencies[0].id);
   }
-  EXPECT_EQ(0u, GetLiveRequests(log.socket_tracker_).size());
-  ASSERT_EQ(1u, GetDeadRequests(log.socket_tracker_).size());
+  EXPECT_EQ(0u, GetLiveSources(log.socket_tracker_).size());
+  ASSERT_EQ(1u, GetDeadSources(log.socket_tracker_).size());
   {
-    PassiveLogCollector::RequestInfo info =
-        GetDeadRequests(log.socket_tracker_)[0];
+    PassiveLogCollector::SourceInfo info =
+        GetDeadSources(log.socket_tracker_)[0];
     EXPECT_EQ(1, info.reference_count);
     EXPECT_EQ(0u, info.dependencies.size());
   }
@@ -321,12 +321,12 @@ TEST(PassiveLogCollectorTest, HoldReferenceToDependentSource) {
                      NULL);
   }
 
-  EXPECT_EQ(0u, GetLiveRequests(log.socket_tracker_).size());
+  EXPECT_EQ(0u, GetLiveSources(log.socket_tracker_).size());
   ASSERT_EQ(SocketTracker::kMaxGraveyardSize + 1,
-            GetDeadRequests(log.socket_tracker_).size());
+            GetDeadSources(log.socket_tracker_).size());
   {
-    PassiveLogCollector::RequestInfo info =
-        GetDeadRequests(log.socket_tracker_)[0];
+    PassiveLogCollector::SourceInfo info =
+        GetDeadSources(log.socket_tracker_)[0];
     EXPECT_EQ(socket_source.id, info.source_id);
     EXPECT_EQ(1, info.reference_count);
     EXPECT_EQ(0u, info.dependencies.size());
@@ -343,11 +343,11 @@ TEST(PassiveLogCollectorTest, HoldReferenceToDependentSource) {
                      NULL);
   }
 
-  EXPECT_EQ(0u, GetLiveRequests(log.url_request_tracker_).size());
+  EXPECT_EQ(0u, GetLiveSources(log.url_request_tracker_).size());
   EXPECT_EQ(RequestTracker::kMaxGraveyardSize,
-            GetDeadRequests(log.url_request_tracker_).size());
+            GetDeadSources(log.url_request_tracker_).size());
 
-  EXPECT_EQ(0u, GetLiveRequests(log.socket_tracker_).size());
+  EXPECT_EQ(0u, GetLiveSources(log.socket_tracker_).size());
   EXPECT_EQ(SocketTracker::kMaxGraveyardSize,
-            GetDeadRequests(log.socket_tracker_).size());
+            GetDeadSources(log.socket_tracker_).size());
 }