Include tab IDs when reporting data use accounting.

chrome/browser/net/chrome_network_delegate.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/chrome_network_delegate.h"
 
 #include <stdlib.h>
 
 #include <vector>
 
 #include "base/base_paths.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/debug/dump_without_crashing.h"
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
+#include "base/memory/weak_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/metrics/user_metrics.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_member.h"
 #include "base/prefs/pref_service.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/content_settings/cookie_settings_factory.h"
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
 #include "chrome/browser/net/chrome_extensions_network_delegate.h"
 #include "chrome/browser/net/connect_interceptor.h"
 #include "chrome/browser/net/request_source_bandwidth_histograms.h"
 #include "chrome/browser/net/safe_search_util.h"
 #include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/sessions/session_tab_helper.h"
 #include "chrome/browser/task_management/task_manager_interface.h"
 #include "chrome/common/pref_names.h"
 #include "components/content_settings/core/browser/cookie_settings.h"
 #include "components/data_usage/core/data_use_aggregator.h"
 #include "components/domain_reliability/monitor.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_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 "content/public/common/content_switches.h"
 #include "content/public/common/process_type.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/cookies/canonical_cookie.h"
 #include "net/cookies/cookie_options.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_status_code.h"
 #include "net/log/net_log.h"
 #include "net/url_request/url_request.h"
+#include "url/gurl.h"
 
 #if defined(OS_ANDROID)
 #include "chrome/browser/io_thread.h"
 #include "chrome/browser/precache/precache_manager_factory.h"
 #include "components/precache/content/precache_manager.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "base/sys_info.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 205 matching lines @@
 
   int64 size = request->received_response_content_length();
   if (size >= 0 && state == CACHE_STATE_NO_LONGER_VALID) {
     UMA_HISTOGRAM_COUNTS("Net.CacheState.AllBytes", size);
     if (CanRequestBeDeltaEncoded(request)) {
       UMA_HISTOGRAM_COUNTS("Net.CacheState.EncodeableBytes", size);
     }
   }
 }
 
+// Attempt to get the associated tab ID for a given render frame. Returns -1 if
+// no associated tab was found.
+int32_t GetTabIdForRenderFrame(int render_process_id, int render_frame_id) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  // TODO(sclittle): For prerendering tabs, investigate if it's possible to find
+  // the original tab that initiated the prerender.

[bengr, 2015/10/27 00:01:47]

Great! Please do.

[sclittle, 2015/10/28 22:30:45]

Maybe later. I think this might be impossible without mucking about in the guts
of prerendering.

+  return SessionTabHelper::IdForTab(content::WebContents::FromRenderFrameHost(
+      content::RenderFrameHost::FromID(render_process_id, render_frame_id)));
+}
+
+void RunTabIdCallbackOnIOThread(
+    const base::Callback<void(int32_t)>& io_thread_callback,
+    int32_t tab_id) {
+  io_thread_callback.Run(tab_id);
+}
+
+void ProvideTabIdFromUIThread(
+    int render_process_id,
+    int render_frame_id,
+    const base::Callback<void(int32_t)>& io_thread_callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&RunTabIdCallbackOnIOThread, io_thread_callback,
+                 GetTabIdForRenderFrame(render_process_id, render_frame_id)));
+}
+
 }  // namespace
 
 ChromeNetworkDelegate::ChromeNetworkDelegate(
     extensions::EventRouterForwarder* event_router,
     BooleanPrefMember* enable_referrers)
     : profile_(NULL),
       enable_referrers_(enable_referrers),
       enable_do_not_track_(NULL),
       force_google_safe_search_(NULL),
       force_youtube_safety_mode_(NULL),
@@ skipping 203 matching lines @@
 void ChromeNetworkDelegate::OnNetworkBytesReceived(
     const net::URLRequest& request,
     int64_t bytes_received) {
 #if defined(ENABLE_TASK_MANAGER)
   // Note: Currently, OnNetworkBytesReceived is only implemented for HTTP jobs,
   // not FTP or other types, so those kinds of bytes will not be reported here.
   task_management::TaskManagerInterface::OnRawBytesRead(request,
                                                         bytes_received);
 #endif  // defined(ENABLE_TASK_MANAGER)
 
-  if (data_use_aggregator_) {
-    if (is_data_usage_off_the_record_) {
-      data_use_aggregator_->ReportOffTheRecordDataUse(0 /* tx_bytes */,
-                                                      bytes_received);
-    } else {
-      data_use_aggregator_->ReportDataUse(request, -1 /* tab_id */,
-                                          0 /* tx_bytes */, bytes_received);
-    }
-  }
+  ReportDataUsageStats(request, 0 /* tx_bytes */, bytes_received);
 }
 
 void ChromeNetworkDelegate::OnNetworkBytesSent(const net::URLRequest& request,
                                                int64_t bytes_sent) {
-  if (data_use_aggregator_) {
-    if (is_data_usage_off_the_record_) {
-      data_use_aggregator_->ReportOffTheRecordDataUse(bytes_sent,
-                                                      0 /* rx_bytes */);
-    } else {
-      data_use_aggregator_->ReportDataUse(request, -1 /* tab_id */, bytes_sent,
-                                          0 /* rx_bytes */);
-    }
-  }
+  ReportDataUsageStats(request, bytes_sent, 0 /* rx_bytes */);
 }
 
 void ChromeNetworkDelegate::OnCompleted(net::URLRequest* request,
                                         bool started) {
 #if !defined(OS_IOS)
   // TODO(amohammadkhan): Verify that there is no double recording in data use
   // of redirected requests.
   data_use_measurement_.ReportDataUseUMA(request);
 #endif
   RecordNetworkErrorHistograms(request);
@@ skipping 198 matching lines @@
   return experimental_web_platform_features_enabled_;
 }
 
 bool ChromeNetworkDelegate::OnCancelURLRequestWithPolicyViolatingReferrerHeader(
     const net::URLRequest& request,
     const GURL& target_url,
     const GURL& referrer_url) const {
   ReportInvalidReferrerSend(target_url, referrer_url);
   return true;
 }
+
+void ChromeNetworkDelegate::ReportDataUsageStats(const net::URLRequest& request,
+                                                 int64_t tx_bytes,
+                                                 int64_t rx_bytes) {
+  if (!data_use_aggregator_)
+    return;
+
+  if (is_data_usage_off_the_record_) {
+    data_use_aggregator_->ReportOffTheRecordDataUse(tx_bytes, rx_bytes);
+    return;
+  }
+
+  base::Callback<void(int32_t)> report_data_use_with_tab_id_callback =
+      base::Bind(&data_usage::DataUseAggregator::ReportDataUse,
+                 data_use_aggregator_->GetWeakPtr(), tx_bytes, rx_bytes,
+                 request.url(), request.request_time(),
+                 request.first_party_for_cookies());
+
+  int render_process_id = -1, render_frame_id = -1;
+  if (!content::ResourceRequestInfo::GetRenderFrameForRequest(
+          &request, &render_process_id, &render_frame_id)) {
+    report_data_use_with_tab_id_callback.Run(-1 /* tab_id */);
+    return;
+  }
+
+  // Hop to the UI thread and back to get the tab ID for the render frame.

[bengr, 2015/10/27 00:01:47]

Can you use PostTaskAndReply?

[sclittle, 2015/10/28 22:30:45]

Not cleanly. We need to pass back the tab ID, and doing that with
PostTaskAndReply would require passing in a scoped_ptr<int32_t> for the tab ID
and modifying it in place, which would be much uglier.

+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&ProvideTabIdFromUIThread, render_process_id, render_frame_id,
+                 report_data_use_with_tab_id_callback));
+}