Support for identifying traffic type in data use ascriber

chrome/browser/data_use_measurement/chrome_data_use_ascriber.cc

 // Copyright 2016 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/data_use_measurement/chrome_data_use_ascriber.h"
 
 #include <string>
 
 #include "base/memory/ptr_util.h"
 #include "chrome/browser/data_use_measurement/chrome_data_use_recorder.h"
@@ skipping 67 matching lines @@
       request->GetUserData(DataUseRecorderEntryAsUserData::kUserDataKey));
   if (user_data)
     return user_data->recorder_entry();
 
   // If request is associated with a ChromeService, create a new
   // DataUseRecorder for it. There is no reason to aggregate URLRequests
   // from ChromeServices into the same DataUseRecorder instance.
   DataUseUserData* service = static_cast<DataUseUserData*>(
       request->GetUserData(DataUseUserData::kUserDataKey));
   if (service) {
-    DataUseRecorderEntry entry = CreateNewDataUseRecorder(request);
-
+    DataUseRecorderEntry entry =
+        CreateNewDataUseRecorder(request, DataUse::SERVICES);
     entry->data_use().set_description(
         DataUseUserData::GetServiceNameAsString(service->service_name()));
     return entry;
   }
 
   int render_process_id = -1;
   int render_frame_id = -1;
   bool has_valid_frame = content::ResourceRequestInfo::GetRenderFrameForRequest(
       request, &render_process_id, &render_frame_id);
   if (has_valid_frame &&
@@ skipping 20 matching lines @@
     const content::ResourceRequestInfo* request_info =
         content::ResourceRequestInfo::ForRequest(request);
     content::ResourceType resource_type =
         request_info ? request_info->GetResourceType()
                      : content::RESOURCE_TYPE_LAST_TYPE;
 
     if (resource_type == content::RESOURCE_TYPE_MAIN_FRAME) {
       content::GlobalRequestID navigation_key =
           request_info->GetGlobalRequestID();
 
-      DataUseRecorderEntry new_entry = CreateNewDataUseRecorder(request);
+      DataUseRecorderEntry new_entry =
+          CreateNewDataUseRecorder(request, DataUse::USER_TRAFFIC);
       new_entry->set_main_frame_request_id(navigation_key);
       pending_navigation_data_use_map_.insert(
           std::make_pair(navigation_key, new_entry));
 
       return new_entry;
     }
 
     DCHECK(frame_iter != main_render_frame_data_use_map_.end());
     auto entry = frame_iter->second;
     request->SetUserData(
         DataUseRecorderEntryAsUserData::kUserDataKey,
         base::MakeUnique<DataUseRecorderEntryAsUserData>(entry));
     entry->AddPendingURLRequest(request);
     return entry;
   }
 
   // Create a new DataUseRecorder for all other requests.
-  DataUseRecorderEntry entry = CreateNewDataUseRecorder(request);
+  DataUseRecorderEntry entry = CreateNewDataUseRecorder(
+      request,
+      content::ResourceRequestInfo::OriginatedFromServiceWorker(request)
+          ? DataUse::SERVICE_WORKER
+          : DataUse::UNKNOWN);
   DataUse& data_use = entry->data_use();
   data_use.set_url(request->url());
   return entry;
 }
 
 void ChromeDataUseAscriber::OnUrlRequestDestroyed(net::URLRequest* request) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   DataUseRecorderEntry entry = GetOrCreateDataUseRecorderEntry(request);
 
@@ skipping 55 matching lines @@
     subframe_to_mainframe_map_.insert(std::make_pair(
         RenderFrameHostID(render_process_id, render_frame_id),
         RenderFrameHostID(main_render_process_id, main_render_frame_id)));
   } else {
     subframe_to_mainframe_map_.insert(
         std::make_pair(RenderFrameHostID(render_process_id, render_frame_id),
                        RenderFrameHostID(render_process_id, render_frame_id)));
     auto frame_iter = main_render_frame_data_use_map_.find(
         RenderFrameHostID(render_process_id, render_frame_id));
     DCHECK(frame_iter == main_render_frame_data_use_map_.end());
-    DataUseRecorderEntry entry = CreateNewDataUseRecorder(nullptr);
+    DataUseRecorderEntry entry =
+        CreateNewDataUseRecorder(nullptr, DataUse::UNKNOWN);
     entry->set_main_frame_id(
         RenderFrameHostID(render_process_id, render_frame_id));
     main_render_frame_data_use_map_.insert(std::make_pair(
         RenderFrameHostID(render_process_id, render_frame_id), entry));
   }
 }
 
 void ChromeDataUseAscriber::RenderFrameDeleted(int render_process_id,
                                                int render_frame_id,
                                                int main_render_process_id,
@@ skipping 42 matching lines @@
   // Find the pending navigation entry.
   auto navigation_iter =
       pending_navigation_data_use_map_.find(global_request_id);
   // We might not find a navigation entry since the pending navigation may not
   // have caused any HTTP or HTTPS URLRequests to be made.
   if (navigation_iter == pending_navigation_data_use_map_.end()) {
     // No pending navigation entry to worry about. However, the old frame entry
     // must be removed from frame map, and possibly marked complete and deleted.
     if (frame_it != main_render_frame_data_use_map_.end()) {
       DataUseRecorderEntry old_frame_entry = frame_it->second;
+      DataUse::TrafficType old_traffic_type =
+          old_frame_entry->data_use().traffic_type();
       main_render_frame_data_use_map_.erase(frame_it);
       if (old_frame_entry->IsDataUseComplete()) {
         OnDataUseCompleted(old_frame_entry);
         data_use_recorders_.erase(old_frame_entry);
       }
 
       // Add a new recorder to the render frame map to replace the deleted one.
       DataUseRecorderEntry entry = data_use_recorders_.emplace(
-          data_use_recorders_.end());
+          data_use_recorders_.end(), old_traffic_type);
       std::pair<int, int> frame_key =
           RenderFrameHostID(render_process_id, render_frame_id);
       entry->set_main_frame_id(frame_key);
       main_render_frame_data_use_map_.insert(std::make_pair(frame_key, entry));
     }
     return;
   }
 
   DataUseRecorderEntry entry = navigation_iter->second;
   pending_navigation_data_use_map_.erase(navigation_iter);
@@ skipping 67 matching lines @@
 void ChromeDataUseAscriber::OnDataUseCompleted(DataUseRecorderEntry entry) {
   // TODO(ryansturm): Notify observers that data use is complete.
 }
 
 std::unique_ptr<URLRequestClassifier>
 ChromeDataUseAscriber::CreateURLRequestClassifier() const {
   return base::MakeUnique<ContentURLRequestClassifier>();
 }
 
 ChromeDataUseAscriber::DataUseRecorderEntry
-ChromeDataUseAscriber::CreateNewDataUseRecorder(net::URLRequest* request) {
-  DataUseRecorderEntry entry = data_use_recorders_.emplace(
-      data_use_recorders_.end());
+ChromeDataUseAscriber::CreateNewDataUseRecorder(
+    net::URLRequest* request,
+    DataUse::TrafficType traffic_type) {
+  DataUseRecorderEntry entry =
+      data_use_recorders_.emplace(data_use_recorders_.end(), traffic_type);
   if (request) {
     entry->AddPendingURLRequest(request);
     request->SetUserData(
         DataUseRecorderEntryAsUserData::kUserDataKey,
         base::MakeUnique<DataUseRecorderEntryAsUserData>(entry));
   }
   return entry;
 }
 
 void ChromeDataUseAscriber::WasShownOrHidden(int main_render_process_id,
@@ skipping 19 matching lines @@
                                                    int new_render_process_id,
                                                    int new_render_frame_id) {
   if (visible_main_render_frames_.find(
           RenderFrameHostID(old_render_process_id, old_render_frame_id)) !=
       visible_main_render_frames_.end()) {
     WasShownOrHidden(new_render_process_id, new_render_frame_id, true);
   }
 }
 
 }  // namespace data_use_measurement