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 70 matching lines @@
 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_.
+  std::string signal("StartLoading: ");
+  signal += std::to_string(base::Time::Now().ToJavaTime());
+  signal_data_.push_back(signal);
+
   // 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_.
+  std::string signal("OnLoad: ");
+  signal += std::to_string(base::Time::Now().ToJavaTime());
+  signal_data_.push_back(signal);
 }
 
 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_.
+    std::string signal("OnDomContentLoaded: ");
+    signal += std::to_string(base::Time::Now().ToJavaTime());
+    signal_data_.push_back(signal);
   }
 }
 
 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_.
+  std::string signal("Snapshotting: ");
+  signal += std::to_string(base::Time::Now().ToJavaTime());
+  signal_data_.push_back(signal);
+
   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