ABANDONED: OOPIFs: Moving stitching of local paths from renderer to browser process.

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 "base/auto_reset.h"
@@ skipping 505 matching lines @@
 // Returns the routing ID of the RenderFrameImpl or RenderFrameProxy
 // associated with |web_frame|.
 int GetRoutingIdForFrameOrProxy(WebFrame* web_frame) {
   if (!web_frame)
     return MSG_ROUTING_NONE;
   if (web_frame->isWebRemoteFrame())
     return RenderFrameProxy::FromWebFrame(web_frame)->routing_id();
   return RenderFrameImpl::FromWebFrame(web_frame)->GetRoutingID();
 }
 
+int GetRoutingIdForFrameOrProxy(const WebFrame* web_frame) {
+  // Const-cast is ok, because we only use |web_frame| to get the frame's
+  // routing id (and this doesn't modify the |web_frame|).
+  return GetRoutingIdForFrameOrProxy(const_cast<WebFrame*>(web_frame));
+}
+
 RenderFrameImpl::CreateRenderFrameImplFunction g_create_render_frame_impl =
     nullptr;
 
 void OnGotContentHandlerID(uint32_t content_handler_id) {}
 
 }  // namespace
 
 // static
 RenderFrameImpl* RenderFrameImpl::Create(RenderViewImpl* render_view,
                                          int32 routing_id) {
@@ skipping 3339 matching lines @@
 
 void RenderFrameImpl::DidPause(WebMediaPlayer* player) {
   Send(new FrameHostMsg_MediaPausedNotification(
       routing_id_, reinterpret_cast<int64>(player)));
 }
 
 void RenderFrameImpl::PlayerGone(WebMediaPlayer* player) {
   DidPause(player);
 }
 
-void RenderFrameImpl::didSerializeDataForFrame(
-    const WebURL& frame_url,
-    const WebCString& data,
-    WebPageSerializerClient::PageSerializationStatus status) {
-  Send(new FrameHostMsg_SerializedHtmlWithLocalLinksResponse(
-      routing_id_, frame_url, data.data(), static_cast<int32>(status)));
+void RenderFrameImpl::writeHtmlFragment(const WebCString& data) {
+  Send(new FrameHostMsg_SerializedHtmlFragment(routing_id_, data));
+}
+
+void RenderFrameImpl::writeLocalPathForSubframe(const WebFrame& subframe) {
+  Send(new FrameHostMsg_SerializedLocalPathForChildFrame(
+      routing_id_, GetRoutingIdForFrameOrProxy(&subframe)));
+}
+
+void RenderFrameImpl::writeLocalPathForSavableResource(
+    const WebURL& savable_resource_url) {
+  Send(new FrameHostMsg_SerializedLocalPathForSavableResource(
+      routing_id_, savable_resource_url));
+}
+
+void RenderFrameImpl::endOfFrame() {
+  Send(new FrameHostMsg_SerializedEndOfFrame(routing_id_));
 }
 
 void RenderFrameImpl::AddObserver(RenderFrameObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void RenderFrameImpl::RemoveObserver(RenderFrameObserver* observer) {
   observer->RenderFrameGone();
   observers_.RemoveObserver(observer);
 }
@@ skipping 545 matching lines @@
   CHECK_EQ(referrer_urls_list.size(), referrer_policies_list.size());
   for (unsigned i = 0; i < referrer_urls_list.size(); ++i) {
     referrers_list.push_back(
         Referrer(referrer_urls_list[i], referrer_policies_list[i]));
   }
 
   Send(new FrameHostMsg_SavableResourceLinksResponse(
       routing_id_, frame_->document().url(), resources_list, referrers_list));
 }
 
-void RenderFrameImpl::OnGetSerializedHtmlWithLocalLinks(
-    std::vector<GURL> original_urls,
-    std::vector<base::FilePath> equivalent_local_paths,
-    base::FilePath local_directory_path) {
-  // Only DCHECK, since the message comes from the trusted browser process.
-  DCHECK(original_urls.size() == equivalent_local_paths.size());
-
-  // Convert std::vector of GURLs to WebVector<WebURL>
-  WebVector<WebURL> weburl_links(original_urls);
-
-  // Convert std::vector of base::FilePath to WebVector<WebString>
-  WebVector<WebString> webstring_paths(equivalent_local_paths.size());
-  for (size_t i = 0; i < equivalent_local_paths.size(); i++)
-    webstring_paths[i] = equivalent_local_paths[i].AsUTF16Unsafe();
-
-  // Serialize the frame (without recursing into subframes).
+void RenderFrameImpl::OnGetSerializedHtmlWithLocalLinks() {
   WebPageSerializer::serialize(GetWebFrame(),
-                               this,   // WebPageSerializerClient.
-                               weburl_links, webstring_paths,
-                               local_directory_path.AsUTF16Unsafe());
+                               this);  // WebPageSerializerClient.
 }
 
 void RenderFrameImpl::OpenURL(WebFrame* frame,
                               const GURL& url,
                               const Referrer& referrer,
                               WebNavigationPolicy policy) {
   DCHECK_EQ(frame_, frame);
 
   FrameHostMsg_OpenURL_Params params;
   params.url = url;
@@ skipping 705 matching lines @@
   mojo::ServiceProviderPtr service_provider(21);
   mojo::URLRequestPtr request(mojo::URLRequest::New());
   request->url = mojo::String::From(url);
   mojo_shell_->ConnectToApplication(request.Pass(), GetProxy(&service_provider),
                                     nullptr, nullptr,
                                     base::Bind(&OnGotContentHandlerID));
   return service_provider.Pass();
 }
 
 }  // namespace content