OOPIFs: Deduplicating MHTML parts across frames.

content/renderer/render_frame_impl.cc

 // Copyright 2013 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 "content/renderer/render_frame_impl.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/debug/asan_invalid_access.h"
 #include "base/debug/dump_without_crashing.h"
 #include "base/files/file.h"
 #include "base/i18n/char_iterator.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/shared_memory.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/process/process.h"
+#include "base/stl_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "cc/base/switches.h"
 #include "components/scheduler/renderer/renderer_scheduler.h"
 #include "content/child/appcache/appcache_dispatcher.h"
 #include "content/child/permissions/permission_dispatcher.h"
 #include "content/child/plugin_messages.h"
 #include "content/child/quota_dispatcher.h"
@@ skipping 85 matching lines @@
 #include "content/renderer/savable_resources.h"
 #include "content/renderer/screen_orientation/screen_orientation_dispatcher.h"
 #include "content/renderer/shared_worker_repository.h"
 #include "content/renderer/skia_benchmarking_extension.h"
 #include "content/renderer/stats_collection_controller.h"
 #include "content/renderer/usb/web_usb_client_impl.h"
 #include "content/renderer/wake_lock/wake_lock_dispatcher.h"
 #include "content/renderer/web_frame_utils.h"
 #include "content/renderer/web_ui_extension.h"
 #include "content/renderer/websharedworker_proxy.h"
+#include "crypto/sha2.h"
 #include "gin/modules/module_registry.h"
 #include "media/audio/audio_output_device.h"
 #include "media/base/audio_renderer_mixer_input.h"
 #include "media/base/media_log.h"
 #include "media/base/media_switches.h"
 #include "media/blink/url_index.h"
 #include "media/blink/webencryptedmediaclient_impl.h"
 #include "media/blink/webmediaplayer_impl.h"
 #include "media/renderers/gpu_video_accelerator_factories.h"
 #include "mojo/common/url_type_converters.h"
@@ skipping 433 matching lines @@
 
 void OnGotContentHandlerID(uint32_t content_handler_id) {}
 
 WebString ConvertRelativePathToHtmlAttribute(const base::FilePath& path) {
   DCHECK(!path.IsAbsolute());
   return WebString::fromUTF8(
       std::string("./") +
       path.NormalizePathSeparatorsTo(FILE_PATH_LITERAL('/')).AsUTF8Unsafe());
 }
 
+// Implementation of WebPageSerializer::MHTMLPartsGenerationDelegate that
+// 1. Bases shouldSkipResource and getContentID responses on contents of
+//    FrameMsg_SerializeAsMHTML_Params.
+// 2. Stores digests of urls of serialized resources (i.e. urls reported via
+//    shouldSkipResource) into |digests_of_uris_of_serialized_resources| passed
+//    to the constructor.
+class MHTMLPartsGenerationDelegate
+    : public WebPageSerializer::MHTMLPartsGenerationDelegate {
+ public:
+  MHTMLPartsGenerationDelegate(
+      const FrameMsg_SerializeAsMHTML_Params& params,
+      std::set<std::string>* digests_of_uris_of_serialized_resources)
+      : params_(params),
+        digests_of_uris_of_serialized_resources_(
+            digests_of_uris_of_serialized_resources) {
+    DCHECK(digests_of_uris_of_serialized_resources_);
+  }
+
+  bool shouldSkipResource(const WebURL& url) override {
+    std::string digest =
+        crypto::SHA256HashString(params_.salt + GURL(url).spec());
+
+    // Skip if the |url| already covered by serialization of an *earlier* frame.
+    if (ContainsKey(params_.digests_of_uris_to_skip, digest))
+      return true;
+
+    // Let's record |url| as being serialized for the *current* frame.
+    auto pair = digests_of_uris_of_serialized_resources_->insert(digest);
+    bool insertion_took_place = pair.second;

[nasko, 2015/12/30 19:22:26]

nit: I'd skip this local variable and DCHECK the pair.second. We already use
this pattern in the constructor.

[Łukasz Anforowicz, 2015/12/30 19:47:10]

I don't know.  I always have to look-up std lib's docs to see what is pair.first
vs pair.second in this case + whether pair.second is insertion_took_place or
there_was_a_conflict.  Having an explicit name in the code makes it easier for
me to read and understand this code without having to look up the docs...

Leaving it as-is for now.

+
+    // Blink should take care of deduping within a single (current) frame.

[nasko, 2015/12/30 19:22:26]

nit: No need for "single (current)" part.

[Łukasz Anforowicz, 2015/12/30 19:47:10]

Done.

+    DCHECK(insertion_took_place);
+
+    return false;
+  }
+
+  WebString getContentID(const WebFrame& frame) override {
+    int routing_id = GetRoutingIdForFrameOrProxy(const_cast<WebFrame*>(&frame));
+    auto it = params_.frame_routing_id_to_content_id.find(routing_id);
+    DCHECK(it != params_.frame_routing_id_to_content_id.end());
+    const std::string& content_id = it->second;
+    return WebString::fromUTF8(content_id);
+  }
+
+ private:
+  const FrameMsg_SerializeAsMHTML_Params& params_;
+  std::set<std::string>* digests_of_uris_of_serialized_resources_;
+
+  DISALLOW_COPY_AND_ASSIGN(MHTMLPartsGenerationDelegate);
+};
+
 bool IsContentWithCertificateErrorsRelevantToUI(
     const blink::WebURL& url,
     const blink::WebCString& security_info,
     const blink::WebURL& main_resource_url,
     const blink::WebCString& main_resource_security_info) {
   content::SSLStatus ssl_status;
   content::SSLStatus main_resource_ssl_status;
   CHECK(DeserializeSecurityInfo(security_info, &ssl_status));
   CHECK(DeserializeSecurityInfo(main_resource_security_info,
                                 &main_resource_ssl_status));
@@ skipping 4171 matching lines @@
         WebURL(url), ConvertRelativePathToHtmlAttribute(local_path)));
   }
 
   // Serialize the frame (without recursing into subframes).
   WebPageSerializer::serialize(GetWebFrame(),
                                this,  // WebPageSerializerClient.
                                weburl_to_local_path);
 }
 
 void RenderFrameImpl::OnSerializeAsMHTML(
-    int job_id,
-    IPC::PlatformFileForTransit file_for_transit,
-    const std::string& std_mhtml_boundary,
-    const std::map<int, std::string>& frame_routing_id_to_content_id,
-    bool is_last_frame) {
+    const FrameMsg_SerializeAsMHTML_Params& params) {
   // Unpack IPC payload.
-  base::File file = IPC::PlatformFileForTransitToFile(file_for_transit);
-  const WebString mhtml_boundary = WebString::fromUTF8(std_mhtml_boundary);
+  base::File file = IPC::PlatformFileForTransitToFile(params.destination_file);
+  const WebString mhtml_boundary =
+      WebString::fromUTF8(params.mhtml_boundary_marker);
   DCHECK(!mhtml_boundary.isEmpty());
-  std::vector<std::pair<WebFrame*, WebString>> web_frame_to_content_id;
-  for (const auto& it : frame_routing_id_to_content_id) {
-    const std::string& content_id = it.second;
-    WebFrame* web_frame = GetWebFrameFromRoutingIdForFrameOrProxy(it.first);
-    if (!web_frame)
-      continue;
-
-    web_frame_to_content_id.push_back(
-        std::make_pair(web_frame, WebString::fromUTF8(content_id)));
-  }
 
   WebData data;
   bool success = true;
+  std::set<std::string> digests_of_uris_of_serialized_resources;
+  MHTMLPartsGenerationDelegate delegate(
+      params, &digests_of_uris_of_serialized_resources);
 
   // Generate MHTML header if needed.
   if (IsMainFrame()) {
     data =
         WebPageSerializer::generateMHTMLHeader(mhtml_boundary, GetWebFrame());
     if (file.WriteAtCurrentPos(data.data(), data.size()) < 0) {
       success = false;
     }
   }
 
   // Generate MHTML parts.
   if (success) {
-    data = WebPageSerializer::generateMHTMLParts(
-        mhtml_boundary, GetWebFrame(), false, web_frame_to_content_id);
+    data = WebPageSerializer::generateMHTMLParts(mhtml_boundary, GetWebFrame(),
+                                                 false, &delegate);
     // TODO(jcivelli): write the chunks in deferred tasks to give a chance to
     //                 the message loop to process other events.
     if (file.WriteAtCurrentPos(data.data(), data.size()) < 0) {
       success = false;
     }
   }
 
   // Generate MHTML footer if needed.
-  if (success && is_last_frame) {
+  if (success && params.is_last_frame) {
     data = WebPageSerializer::generateMHTMLFooter(mhtml_boundary);
     if (file.WriteAtCurrentPos(data.data(), data.size()) < 0) {
       success = false;
     }
   }
 
   // Cleanup and notify the browser process about completion.
   file.Close();  // Need to flush file contents before sending IPC response.
-  Send(new FrameHostMsg_SerializeAsMHTMLResponse(routing_id_, job_id, success));
+  Send(new FrameHostMsg_SerializeAsMHTMLResponse(
+      routing_id_, params.job_id, success,
+      digests_of_uris_of_serialized_resources));
 }
 
 void RenderFrameImpl::OpenURL(const GURL& url,
                               const Referrer& referrer,
                               WebNavigationPolicy policy,
                               bool should_replace_current_entry,
                               bool is_history_navigation_in_new_child) {
   FrameHostMsg_OpenURL_Params params;
   params.url = url;
   params.referrer = referrer;
@@ skipping 806 matching lines @@
       media::ConvertToSwitchOutputDeviceCB(web_callbacks);
   scoped_refptr<media::AudioOutputDevice> device =
       AudioDeviceFactory::NewOutputDevice(routing_id_, 0, sink_id.utf8(),
                                           security_origin);
   media::OutputDeviceStatus status = device->GetDeviceStatus();
   device->Stop();
   callback.Run(status);
 }
 
 }  // namespace content