Propogate the tab foreground, background change events to data use

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 104 matching lines @@
 
     if (resource_type == content::RESOURCE_TYPE_MAIN_FRAME) {
       content::GlobalRequestID navigation_key =
           request_info->GetGlobalRequestID();
 
       DataUseRecorderEntry new_entry = CreateNewDataUseRecorder(request);
       new_entry->set_main_frame_request_id(navigation_key);
       pending_navigation_data_use_map_.insert(
           std::make_pair(navigation_key, new_entry));
 
+      if (visible_main_render_frames_.find(main_frame_key_iter->second) !=
+          visible_main_render_frames_.end()) {
+        new_entry->set_is_visible(true);

[RyanSturm, 2016/12/13 22:04:19]

Instead of marking it visible here, I think it makes more sense to do that when
the load commits. I added a comment below of where I think it would be best to
set the visibility state.

Before the load commits, the URLRequest isn't really visible as the old page
load is still shown until the load commits.

WDYT?

[Raj, 2016/12/14 23:00:50]

Done.

+      }
+
       return new_entry;
     }
 
     DCHECK(frame_iter != main_render_frame_data_use_map_.end());
     auto entry = frame_iter->second;
     request->SetUserData(DataUseRecorderEntryAsUserData::kUserDataKey,
                          new DataUseRecorderEntryAsUserData(entry));
     entry->AddPendingURLRequest(request);
     return entry;
   }
@@ skipping 97 matching lines @@
   if (main_render_process_id == -1 && main_render_frame_id == -1) {
     auto frame_iter = main_render_frame_data_use_map_.find(key);
     DataUseRecorderEntry entry = frame_iter->second;
     if (entry->IsDataUseComplete()) {
       OnDataUseCompleted(entry);
       data_use_recorders_.erase(entry);
     }
     main_render_frame_data_use_map_.erase(frame_iter);
   }
   subframe_to_mainframe_map_.erase(key);
+  visible_main_render_frames_.erase(key);
 }
 
 void ChromeDataUseAscriber::DidStartMainFrameNavigation(
     GURL gurl,
     int render_process_id,
     int render_frame_id,
     void* navigation_handle) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 }
 
@@ skipping 62 matching lines @@
       old_frame_entry->AddPendingURLRequest(request);
     }
 
     entry->RemoveAllPendingURLRequests();
 
     data_use_recorders_.erase(entry);
   } else {
     // Navigation is not same page, so remove old entry from
     // |main_render_frame_data_use_map_|, possibly marking it complete.
     main_render_frame_data_use_map_.erase(frame_it);
     if (old_frame_entry->IsDataUseComplete()) {

[RyanSturm, 2016/12/13 22:04:19]

Copy the visibility state from old_frame_entry to entry.

[Raj, 2016/12/14 23:00:50]

Acknowledged.

       OnDataUseCompleted(old_frame_entry);
       data_use_recorders_.erase(old_frame_entry);
     }
 
     DataUse& data_use = entry->data_use();
 
     DCHECK(!data_use.url().is_valid() || data_use.url() == gurl)
         << "is valid: " << data_use.url().is_valid()
         << "; data_use.url(): " << data_use.url().spec()
         << "; gurl: " << gurl.spec();
@@ skipping 20 matching lines @@
   DataUseRecorderEntry entry = data_use_recorders_.emplace(
       data_use_recorders_.end());
   if (request) {
     entry->AddPendingURLRequest(request);
     request->SetUserData(DataUseRecorderEntryAsUserData::kUserDataKey,
                          new DataUseRecorderEntryAsUserData(entry));
   }
   return entry;
 }
 
+void ChromeDataUseAscriber::WasShownOrHidden(int main_render_process_id,
+                                             int main_render_frame_id,
+                                             bool visible) {
+  RenderFrameHostID main_render_frame_host_id(main_render_process_id,
+                                              main_render_frame_id);
+
+  auto frame_iter =
+      main_render_frame_data_use_map_.find(main_render_frame_host_id);
+  if (frame_iter != main_render_frame_data_use_map_.end())
+    frame_iter->second->set_is_visible(visible);
+
+  if (visible) {
+    visible_main_render_frames_.insert(main_render_frame_host_id);
+  } else {
+    visible_main_render_frames_.erase(main_render_frame_host_id);
+  }
+}
+
+void ChromeDataUseAscriber::RenderFrameHostChanged(int old_render_process_id,
+                                                   int old_render_frame_id,
+                                                   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