Save-Page-As-Complete-Html: Each frame links to a distinct local file.

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 <utility>
 #include <vector>
@@ skipping 581 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 WebFrameSerializer::LinkRewritingDelegate that responds
+// based on the payload of FrameMsg_GetSerializedHtmlWithLocalLinks.
+class LinkRewritingDelegate : public WebFrameSerializer::LinkRewritingDelegate {
+ public:
+  LinkRewritingDelegate(
+      const std::map<GURL, base::FilePath>& url_to_local_path,
+      const std::map<int, base::FilePath>& frame_routing_id_to_local_path)
+      : url_to_local_path_(url_to_local_path),
+        frame_routing_id_to_local_path_(frame_routing_id_to_local_path) {}
+
+  bool rewriteFrameSource(WebFrame* frame, WebString* rewritten_link) override {
+    int routing_id = GetRoutingIdForFrameOrProxy(frame);
+    auto it = frame_routing_id_to_local_path_.find(routing_id);
+    if (it == frame_routing_id_to_local_path_.end())
+      return false;  // This can happen because of https://crbug.com/541354.
+
+    const base::FilePath& local_path = it->second;
+    *rewritten_link = ConvertRelativePathToHtmlAttribute(local_path);
+    return true;
+  }
+
+  bool rewriteLink(const WebURL& url, WebString* rewritten_link) override {
+    auto it = url_to_local_path_.find(url);
+    if (it == url_to_local_path_.end())
+      return false;
+
+    const base::FilePath& local_path = it->second;
+    *rewritten_link = ConvertRelativePathToHtmlAttribute(local_path);
+    return true;
+  }
+
+ private:
+  const std::map<GURL, base::FilePath>& url_to_local_path_;
+  const std::map<int, base::FilePath>& frame_routing_id_to_local_path_;
+};
+
 // Implementation of WebFrameSerializer::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 WebFrameSerializer::MHTMLPartsGenerationDelegate {
  public:
   MHTMLPartsGenerationDelegate(
@@ skipping 14 matching lines @@
       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;
     DCHECK(insertion_took_place);  // Blink should dedupe within a frame.
 
     return false;
   }
 
-  WebString getContentID(const WebFrame& frame) override {
-    int routing_id = GetRoutingIdForFrameOrProxy(const_cast<WebFrame*>(&frame));
+  WebString getContentID(WebFrame* frame) override {
+    int routing_id = GetRoutingIdForFrameOrProxy(frame);
 
     auto it = params_.frame_routing_id_to_content_id.find(routing_id);
     if (it == params_.frame_routing_id_to_content_id.end())
       return WebString();
 
     const std::string& content_id = it->second;
     return WebString::fromUTF8(content_id);
   }
 
  private:
@@ skipping 4256 matching lines @@
   }
 
   Referrer referrer =
       Referrer(frame_->document().url(), frame_->document().referrerPolicy());
 
   Send(new FrameHostMsg_SavableResourceLinksResponse(
       routing_id_, resources_list, referrer, subframes));
 }
 
 void RenderFrameImpl::OnGetSerializedHtmlWithLocalLinks(
-    const std::map<GURL, base::FilePath>& url_to_local_path) {
+    const std::map<GURL, base::FilePath>& url_to_local_path,
+    const std::map<int, base::FilePath>& frame_routing_id_to_local_path) {
   // Convert input to the canonical way of passing a map into a Blink API.
-  std::vector<std::pair<WebURL, WebString>> weburl_to_local_path;
-  for (const auto& it : url_to_local_path) {
-    const GURL& url = it.first;
-    const base::FilePath& local_path = it.second;
-    weburl_to_local_path.push_back(std::make_pair(
-        WebURL(url), ConvertRelativePathToHtmlAttribute(local_path)));
-  }
+  LinkRewritingDelegate delegate(url_to_local_path,
+                                 frame_routing_id_to_local_path);
 
   // Serialize the frame (without recursing into subframes).
   WebFrameSerializer::serialize(GetWebFrame(),
                                 this,  // WebFrameSerializerClient.
-                                weburl_to_local_path);
+                                &delegate);
 }
 
 void RenderFrameImpl::OnSerializeAsMHTML(
     const FrameMsg_SerializeAsMHTML_Params& params) {
   // Unpack IPC payload.
   base::File file = IPC::PlatformFileForTransitToFile(params.destination_file);
   const WebString mhtml_boundary =
       WebString::fromUTF8(params.mhtml_boundary_marker);
   DCHECK(!mhtml_boundary.isEmpty());
 
@@ skipping 1107 matching lines @@
                                     int match_count,
                                     int ordinal,
                                     const WebRect& selection_rect,
                                     bool final_status_update) {
   Send(new FrameHostMsg_Find_Reply(routing_id_, request_id, match_count,
                                    selection_rect, ordinal,
                                    final_status_update));
 }
 
 }  // namespace content