Get signals working in the EXTRA_DATA section of MHTML

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"
+#include "base/time/time.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
 #include "net/base/network_change_notifier.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace {
 // Whether to report DomContentLoaded event to the snapshot controller.
 bool kConsiderDclForSnapshot = false;
@@ skipping 60 matching lines @@
       snapshot_controller_(nullptr),
       browser_context_(browser_context),
       is_lowbar_met_(false) {
   adapter_.reset(new PrerenderAdapter(this));
 }
 
 PrerenderingLoader::~PrerenderingLoader() {
   CancelPrerender();
 }
 
+void PrerenderingLoader::AddLoadingSignal(const char* signal_name) {
+  std::string signal(signal_name);
+  signal += ": ";
+  // We need a time in milliseconds, and JavaTime provides that.
+  signal += std::to_string(base::Time::Now().ToJavaTime());

[Dmitry Titov, 2017/03/29 18:53:06]

this is not using ToJavaTime() for what it is intended. 
Not sure why we need a wall clock timestamps BTW. Isn't it a delay from the
navigation that you want? If so, it'd be more straightforward to snapshot a
TickTime at the start and then compute TimeDeltas and use its ToMilliseconds
method. 

[Pete Williamson, 2017/03/29 22:05:42]

Reading the descriptions at the top of time.h, it says that TimeTicks may stand
still if the computer is suspended.  I'm not sure what "suspended" means here,
and was concerned that it might consider running in background as "suspended".

I've recoded using TimeTicks assuming that suspended means the CPU is not
running.

+  signal_data_.push_back(signal);
+}
+
 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;
   }
 
+  // Add this signal to signal_data_.
+  AddLoadingSignal("StartLoading");
+
   // Create a WebContents instance to define and hold a SessionStorageNamespace
   // for this load request.
   DCHECK(!session_contents_.get());
   std::unique_ptr<content::WebContents> new_web_contents(
       content::WebContents::Create(
           content::WebContents::CreateParams(browser_context_)));
   content::SessionStorageNamespace* sessionStorageNamespace =
       new_web_contents->GetController().GetDefaultSessionStorageNamespace();
   gfx::Size renderWindowSize = new_web_contents->GetContainerBounds().size();
   bool accepted = adapter_->StartPrerender(
@@ skipping 34 matching lines @@
   adapter_ = std::move(prerender_adapter);
 }
 
 void PrerenderingLoader::OnPrerenderStopLoading() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(!IsIdle());
   DCHECK(adapter_->GetWebContents());
   // Inform SnapshotController of OnLoad event so it can determine
   // when to consider it really LOADED.
   snapshot_controller_->DocumentOnLoadCompletedInMainFrame();
+
+  // Add this signal to signal_data_.
+  AddLoadingSignal("OnLoad");
 }
 
 void PrerenderingLoader::OnPrerenderDomContentLoaded() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(!IsIdle());
   if (!adapter_->GetWebContents()) {
     // Without a WebContents object at this point, we are done.
     HandleLoadingStopped();
   } else {
     is_lowbar_met_ = true;
     if (kConsiderDclForSnapshot) {
       // Inform SnapshotController of DomContentLoaded event so it can
       // determine when to consider it really LOADED (e.g., some multiple
       // second delay from this event).
       snapshot_controller_->DocumentAvailableInMainFrame();
     }
+
+    // Add this signal to signal_data_.
+    AddLoadingSignal("OnDomContentLoaded");
   }
 }
 
 void PrerenderingLoader::OnPrerenderStop() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   HandleLoadingStopped();
 }
 
 void PrerenderingLoader::OnPrerenderNetworkBytesChanged(int64_t bytes) {
   if (state_ == State::LOADING)
     progress_callback_.Run(bytes);
 }
 
 void PrerenderingLoader::StartSnapshot() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  // Add this signal to signal_data_.
+  AddLoadingSignal("Snapshotting");
+
   HandleLoadEvent();
 }
 
 bool PrerenderingLoader::IsLowbarMet() {
   return is_lowbar_met_;
 }
 
 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
@@ skipping 72 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