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 607 matching lines @@
     // TODO(kenrb): Observing shouldn't be necessary when we sort out
     // WasShown and WasHidden, separating page-level visibility from
     // frame-level visibility.
     render_frame->render_widget_->RegisterRenderFrame(render_frame);
   }
 
   render_frame->Initialize();
 }
 
 // static
+const RenderFrame* RenderFrame::FromWebFrame(const blink::WebFrame* web_frame) {
+  return RenderFrameImpl::FromWebFrame(web_frame);
+}
+
+// static
 RenderFrame* RenderFrame::FromWebFrame(blink::WebFrame* web_frame) {
-  return RenderFrameImpl::FromWebFrame(web_frame);
+  return const_cast<RenderFrame*>(RenderFrame::FromWebFrame(
+      static_cast<const blink::WebFrame*>(web_frame)));
 }
 
 // static
-RenderFrameImpl* RenderFrameImpl::FromWebFrame(blink::WebFrame* web_frame) {
-  FrameMap::iterator iter = g_frame_map.Get().find(web_frame);
+const RenderFrameImpl* RenderFrameImpl::FromWebFrame(
+    const blink::WebFrame* web_frame) {
+  const auto& const_frame_map = const_cast<const FrameMap&>(g_frame_map.Get());
+  FrameMap::const_iterator iter =
+      const_frame_map.find(const_cast<blink::WebFrame*>(web_frame));
   if (iter != g_frame_map.Get().end())
     return iter->second;
   return NULL;
 }
 
 // static
+RenderFrameImpl* RenderFrameImpl::FromWebFrame(blink::WebFrame* web_frame) {
+  return const_cast<RenderFrameImpl*>(RenderFrameImpl::FromWebFrame(
+      static_cast<const blink::WebFrame*>(web_frame)));
+}
+
+// static
 void RenderFrameImpl::InstallCreateHook(
     CreateRenderFrameImplFunction create_render_frame_impl) {
   CHECK(!g_create_render_frame_impl);
   g_create_render_frame_impl = create_render_frame_impl;
 }
 
 // static
 blink::WebFrame* RenderFrameImpl::ResolveOpener(int opener_frame_routing_id,
                                                 int* opener_view_routing_id) {
   if (opener_view_routing_id)
@@ skipping 1214 matching lines @@
   if (BrowserPluginManager::Get())
     BrowserPluginManager::Get()->DidCommitCompositorFrame(GetRoutingID());
   FOR_EACH_OBSERVER(
       RenderFrameObserver, observers_, DidCommitCompositorFrame());
 }
 
 RenderView* RenderFrameImpl::GetRenderView() {
   return render_view_.get();
 }
 
-int RenderFrameImpl::GetRoutingID() {
+int RenderFrameImpl::GetRoutingID() const {
   return routing_id_;
 }
 
 blink::WebLocalFrame* RenderFrameImpl::GetWebFrame() {
   DCHECK(frame_);
   return frame_;
 }
 
 WebElement RenderFrameImpl::GetFocusedElement() const {
   WebDocument doc = frame_->document();
@@ skipping 2007 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) {
+  int subframe_routing_id;
+  if (subframe.isWebRemoteFrame()) {
+    subframe_routing_id =
+        RenderFrameProxy::FromWebFrame(&subframe)->routing_id();
+  } else {
+    DCHECK(subframe.isWebLocalFrame());
+    subframe_routing_id = RenderFrame::FromWebFrame(&subframe)->GetRoutingID();
+  }
+
+  Send(new FrameHostMsg_SerializedLocalPathForSubFrame(routing_id_,
+                                                       subframe_routing_id));
+}
+
+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 529 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 680 matching lines @@
   mojo::ServiceProviderPtr service_provider;
   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