fix build break

chrome/browser/net/load_time_stats.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 "chrome/browser/net/load_time_stats.h"
 
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/string_number_conversions.h"
 #include "base/timer.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/web_contents.h"
 #include "net/url_request/url_request.h"
 
 using content::BrowserThread;
 using content::RenderViewHost;
 using content::ResourceRequestInfo;
 using std::string;
 
-#if defined(COMPILER_GCC)
-
-namespace BASE_HASH_NAMESPACE {
-template <>
-struct hash<const net::URLRequest*> {
-  std::size_t operator()(const net::URLRequest* value) const {
-    return reinterpret_cast<std::size_t>(value);
-  }
-};
-}
-
-#endif
-
 namespace {
 
 bool GetRenderView(const net::URLRequest& request,
                    int* process_id, int* route_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(&request);
   if (!info)
     return false;
   return info->GetAssociatedRenderView(process_id, route_id);
 }
@@ skipping 133 matching lines @@
   RenderViewId render_view_id_;
   PerStatusStatsArray per_status_stats_;
   bool spinner_started_;
   base::TimeTicks load_start_time_;
   int next_timer_index_;
   base::Timer timer_;
   // Currently active URLRequests.
   RequestMap active_requests_;
 };
 
+class LoadTimeStats::URLRequestStats {
+ public:
+  URLRequestStats()
+      : done_(false),
+        start_time_(GetCurrentTime()),
+        status_(REQUEST_STATUS_ACTIVE) {
+  }
+  void OnStatusChange(RequestStatus new_status) {
+    if (done_)
+      return;
+    DCHECK_GE(status_, 0);
+    DCHECK_GE(new_status, 0);
+    DCHECK_LE(status_, REQUEST_STATUS_ACTIVE);
+    DCHECK_LE(new_status, REQUEST_STATUS_ACTIVE);
+    base::TimeTicks now = GetCurrentTime();
+    base::TimeDelta elapsed = now - start_time_;
+    status_times_[status_] += elapsed;
+    start_time_ = now;
+    status_ = new_status;
+  }
+  void RequestDone() {
+    DCHECK(!done_);
+    // Dummy status change to add last elapsed time.
+    OnStatusChange(REQUEST_STATUS_ACTIVE);
+    done_ = true;
+
+    UMA_HISTOGRAM_TIMES("LoadTimeStats.Request_CacheWait_Time",
+                        status_times_[REQUEST_STATUS_CACHE_WAIT]);
+    UMA_HISTOGRAM_TIMES("LoadTimeStats.Request_NetworkWait_Time",
+                        status_times_[REQUEST_STATUS_NETWORK_WAIT]);
+    UMA_HISTOGRAM_TIMES("LoadTimeStats.Request_Active_Time",
+                        status_times_[REQUEST_STATUS_ACTIVE]);
+
+    base::TimeDelta total_time;
+    for (int status = REQUEST_STATUS_CACHE_WAIT;
+         status <= REQUEST_STATUS_ACTIVE;
+         status++) {
+      total_time += status_times_[status];
+    }
+    if (total_time.InMilliseconds() <= 0)
+      return;
+
+    for (int status = REQUEST_STATUS_CACHE_WAIT;
+         status <= REQUEST_STATUS_ACTIVE;
+         status++) {
+      int64 fraction_percentage = 100 *
+          status_times_[status].InMilliseconds() /
+          total_time.InMilliseconds();
+      DCHECK(fraction_percentage >= 0 && fraction_percentage <= 100);
+      switch (status) {
+        case REQUEST_STATUS_CACHE_WAIT:
+          UMA_HISTOGRAM_PERCENTAGE(
+              "LoadTimeStats.Request_CacheWait_Percentage",
+              fraction_percentage);
+          break;
+        case REQUEST_STATUS_NETWORK_WAIT:
+          UMA_HISTOGRAM_PERCENTAGE(
+              "LoadTimeStats.Request_NetworkWait_Percentage",
+              fraction_percentage);
+          break;
+        case REQUEST_STATUS_ACTIVE:
+          UMA_HISTOGRAM_PERCENTAGE(
+              "LoadTimeStats.Request_Active_Percentage", fraction_percentage);
+          break;
+      }
+    }
+  }
+
+ private:
+  base::TimeTicks GetCurrentTime() {
+    return base::TimeTicks::Now();
+  }
+  bool done_;
+  base::TimeTicks start_time_;
+  RequestStatus status_;
+  base::TimeDelta status_times_[REQUEST_STATUS_MAX];
+};
+
 LoadTimeStatsTabHelper::LoadTimeStatsTabHelper(TabContents* tab)
     : content::WebContentsObserver(tab->web_contents()) {
   is_otr_profile_ = tab->profile()->IsOffTheRecord();
 }
 
 LoadTimeStatsTabHelper::~LoadTimeStatsTabHelper() {
 }
 
 void LoadTimeStatsTabHelper::DidStartProvisionalLoadForFrame(
     int64 frame_id,
@@ skipping 48 matching lines @@
                 0, 101, 51, base::Histogram::kUmaTargetedHistogramFlag));
       }
       DCHECK_EQ(histograms_[status][histogram_type].size(),
                 arraysize(kStatsCollectionTimesMs));
     }
   }
 }
 
 LoadTimeStats::~LoadTimeStats() {
   STLDeleteValues(&tab_load_stats_);
+  STLDeleteValues(&request_stats_);
+}
+
+LoadTimeStats::URLRequestStats* LoadTimeStats::GetRequestStats(
+    const net::URLRequest* request) {
+  RequestStatsMap::const_iterator it = request_stats_.find(request);
+  if (it != request_stats_.end())
+    return it->second;
+  URLRequestStats* new_request_stats = new URLRequestStats();
+  request_stats_[request] = new_request_stats;
+  return new_request_stats;
 }
 
 LoadTimeStats::TabLoadStats* LoadTimeStats::GetTabLoadStats(
     std::pair<int, int> render_view_id) {
   TabLoadStatsMap::const_iterator it = tab_load_stats_.find(render_view_id);
   if (it != tab_load_stats_.end())
     return it->second;
   TabLoadStats* new_tab_load_stats = new TabLoadStats(render_view_id, this);
   tab_load_stats_[render_view_id] = new_tab_load_stats;
   return new_tab_load_stats;
@@ skipping 58 matching lines @@
     DCHECK_GE(status_stats->num_active(), 0);
   }
   if (new_status != REQUEST_STATUS_NONE) {
     TabLoadStats::PerStatusStats* status_stats =
         &(stats->per_status_stats()[new_status]);
     DCHECK_GE(status_stats->num_active(), 0);
     status_stats->UpdateTotalTimes();
     status_stats->IncrementNumActive();
     DCHECK_GE(status_stats->num_active(), 0);
     stats->active_requests()[&request] = new_status;
+    URLRequestStats* request_stats = GetRequestStats(&request);
+    request_stats->OnStatusChange(new_status);
   } else {
     stats->active_requests().erase(&request);
   }
 }
 
+void LoadTimeStats::OnURLRequestDestroyed(const net::URLRequest& request) {
+  if (request_stats_.count(&request) < 1)
+    return;
+  scoped_ptr<URLRequestStats> request_stats(GetRequestStats(&request));
+  request_stats_.erase(&request);
+  request_stats->RequestDone();
+}
+
 void LoadTimeStats::OnTabEvent(std::pair<int, int> render_view_id,
                             TabEvent event) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   TabLoadStats* stats = GetTabLoadStats(render_view_id);
   if (event == SPINNER_START) {
     stats->set_spinner_started(true);
     stats->set_load_start_time(base::TimeTicks::Now());
     for (int status = REQUEST_STATUS_CACHE_WAIT;
          status <= REQUEST_STATUS_ACTIVE; status++) {
       stats->per_status_stats()[status].ResetTimes();
@@ skipping 104 matching lines @@
   if (type == ChromeURLRequestContext::CONTEXT_TYPE_MAIN)
     main_request_contexts_.insert(context);
 }
 
 void LoadTimeStats::UnregisterURLRequestContext(
     const net::URLRequestContext* context) {
   main_request_contexts_.erase(context);
 }
 
 }  // namespace chrome_browser_net