Add a way to send the resource percentage signal to the RC.

chrome/browser/android/offline_pages/prerendering_loader.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/android/offline_pages/prerendering_loader.h"
 
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 70 matching lines @@
   load_start_time_ = base::TimeTicks::Now();
 }
 
 void PrerenderingLoader::AddLoadingSignal(const char* signal_name) {
   base::TimeTicks current_time = base::TimeTicks::Now();
   base::TimeDelta delay_so_far = current_time - load_start_time_;
   double delay = delay_so_far.InMilliseconds();
   signal_data_.SetDouble(signal_name, delay);
 }
 
+void PrerenderingLoader::AddResourceSignal(const ResourceDataType type,

[Dmitry Titov, 2017/05/18 02:28:10]

It is not clear why these are called "Add*" when they constantly re-set the
values, since they are called up to 2 times per each loaded resource... Would it
be better to call them SetResourceSignal?

[Pete Williamson, 2017/05/24 01:01:50]

Moved the content into ObserverResourceTracking everywhere.

+                                           int64_t started_count,
+                                           int64_t completed_count) {
+  double percentage = 100 * static_cast<double>(completed_count) /
+                      static_cast<double>(started_count);
+  // TODO(petewil): Use actual signal type instead of hardcoding name to image.
+  signal_data_.SetDouble("ImagePercentage", percentage);
+  signal_data_.SetDouble("StartedImages", started_count);
+  signal_data_.SetDouble("CompletedImages", completed_count);
+}
+
 bool PrerenderingLoader::LoadPage(const GURL& url,
                                   const LoadPageCallback& load_done_callback,
                                   const ProgressCallback& progress_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (!IsIdle()) {
     DVLOG(1)
         << "WARNING: Existing request in progress or waiting for StopLoading()";
     return false;
   }
 
@@ skipping 91 matching lines @@
   // Add this signal to signal_data_.
   AddLoadingSignal("Snapshotting");
 
   HandleLoadEvent();
 }
 
 bool PrerenderingLoader::IsLowbarMet() {
   return is_lowbar_met_;
 }
 
+void PrerenderingLoader::ObserveResourceTracking(const ResourceDataType type,
+                                                 int64_t started_count,
+                                                 int64_t completed_count) {
+  // Add the signal to extra data, and use for tracking.
+  if (type == ResourceDataType::IMAGE)

[Dmitry Titov, 2017/05/18 02:28:10]

This conditional can go to AddResourceSignal where the rest of the logic is,
then this method can be just removed.

[Pete Williamson, 2017/05/24 01:01:50]

Kept this method, since it is the exposed interface method, but moved
AddResourceSignal into here.

+    AddResourceSignal(type, started_count, completed_count);
+}
+
 void PrerenderingLoader::HandleLoadEvent() {
   // If still loading, check if the load succeeded or not, then update
   // the internal state (LOADED for success or IDLE for failure) and post
   // callback.
   // Note: it is possible to receive a load event (e.g., if timeout-based)
   // after the request has completed via another path (e.g., canceled) so
   // the Loader may be idle at this point.
 
   if (IsIdle() || IsLoaded())
     return;
@@ skipping 65 matching lines @@
   if (adapter_->IsActive()) {
     adapter_->DestroyActive();
   }
   snapshot_controller_.reset(nullptr);
   session_contents_.reset(nullptr);
   state_ = State::IDLE;
   is_lowbar_met_ = false;
 }
 
 }  // namespace offline_pages