Get signals working in the EXTRA_DATA section of MHTML

chrome/browser/android/offline_pages/prerendering_offliner.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_offliner.h"
 
 #include "base/bind.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/sys_info.h"
 #include "chrome/browser/android/offline_pages/offline_page_mhtml_archiver.h"
 #include "chrome/browser/android/offline_pages/offliner_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "components/offline_pages/core/background/offliner_policy.h"
 #include "components/offline_pages/core/background/save_page_request.h"
 #include "components/offline_pages/core/client_namespace_constants.h"
 #include "components/offline_pages/core/downloads/download_ui_adapter.h"
+#include "components/offline_pages/core/offline_page_feature.h"
 #include "components/offline_pages/core/offline_page_model.h"
 #include "content/public/browser/browser_context.h"
+#include "content/public/browser/mhtml_extra_parts.h"
 #include "content/public/browser/web_contents.h"
 
+namespace {
+const char kContentType[] = "text/plain";
+}  // namespace
+
 namespace offline_pages {
 
 PrerenderingOffliner::PrerenderingOffliner(
     content::BrowserContext* browser_context,
     const OfflinerPolicy* policy,
     OfflinePageModel* offline_page_model)
     : browser_context_(browser_context),
       policy_(policy),
       offline_page_model_(offline_page_model),
       pending_request_(nullptr),
@@ skipping 45 matching lines @@
     save_page_params.client_id = request.client_id();
     save_page_params.proposed_offline_id = request.request_id();
     save_page_params.is_background = true;
     // Pass in the original URL if it is different from the last committed URL
     // when redirects occur.
     if (!request.original_url().is_empty())
       save_page_params.original_url = request.original_url();
     else if (save_page_params.url != request.url())
       save_page_params.original_url = request.url();
 
+    if (IsOfflinePagesLoadSignalCollectingEnabled()) {
+      // Stash loading signals for writing when we write out the MHTML.
+      std::string body = SerializeLoadingSignalData();
+      std::string content_type = kContentType;
+      std::string content_location = "cid:signal-data-" +
+                                     std::to_string(request.request_id()) +
+                                     "@mhtml.blink";
+
+      content::MHTMLExtraParts* extra_parts =
+          content::MHTMLExtraParts::FromWebContents(web_contents);
+      DCHECK(extra_parts);
+
+      extra_parts->AddExtraMHTMLPart(content_type, content_location, body);
+    }
+
     SavePage(save_page_params, std::move(archiver),
              base::Bind(&PrerenderingOffliner::OnSavePageDone,
                         weak_ptr_factory_.GetWeakPtr(), request));
   } else {
     // Clear pending request and app listener then run completion callback.
     pending_request_.reset(nullptr);
     app_listener_.reset(nullptr);
     completion_callback_.Run(request, load_status);
   }
 }
 
+std::string PrerenderingOffliner::SerializeLoadingSignalData() {
+  // Write the signal data into a single string.
+  std::string signal_string;
+  const std::vector<std::string>& signals = loader_->GetLoadingSignalData();
+
+  // TODO(petewil): Convert this to JSON, use json_writer.h
+  for (std::string signal : signals) {
+    signal_string += signal;
+    signal_string += "\r\n";
+  }
+  return signal_string;
+}
+
 void PrerenderingOffliner::OnSavePageDone(
     const SavePageRequest& request,
     SavePageResult save_result,
     int64_t offline_id) {
   // Check if request is still pending receiving a callback.
   if (!pending_request_)
     return;
 
   // Also check that this completed request is same as the pending one
   // (since SavePage request is not cancel-able currently and could be old).
@@ skipping 176 matching lines @@
 void PrerenderingOffliner::HandleApplicationStateChangeCancel(
     const SavePageRequest& request,
     int64_t offline_id) {
   // This shouldn't be immediate, but account for case where request was reset
   // while waiting for callback.
   if (pending_request_ && pending_request_->request_id() != offline_id)
     return;
   completion_callback_.Run(request, RequestStatus::FOREGROUND_CANCELED);
 }
 }  // namespace offline_pages