Content API changes to improve DOM stitching in ThreatDetails code.

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 600 matching lines @@
 // 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);
+    int routing_id = RenderFrame::GetRoutingIdForWebFrame(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 {
@@ skipping 38 matching lines @@
 
     // Let's record |url| as being serialized for the *current* frame.
     auto pair = serialized_resources_uri_digests_->insert(digest);
     bool insertion_took_place = pair.second;
     DCHECK(insertion_took_place);  // Blink should dedupe within a frame.
 
     return false;
   }
 
   WebString GetContentID(WebFrame* frame) override {
-    int routing_id = GetRoutingIdForFrameOrProxy(frame);
+    int routing_id = RenderFrame::GetRoutingIdForWebFrame(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);
   }
 
   blink::WebFrameSerializerCacheControlPolicy CacheControlPolicy() override {
@@ skipping 365 matching lines @@
 // static
 void RenderFrame::ForEach(RenderFrameVisitor* visitor) {
   FrameMap* frames = g_frame_map.Pointer();
   for (FrameMap::iterator it = frames->begin(); it != frames->end(); ++it) {
     if (!visitor->Visit(it->second))
       return;
   }
 }
 
 // static
+int RenderFrame::GetRoutingIdForWebFrame(blink::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();
+}
+
+// static
 RenderFrameImpl* RenderFrameImpl::FromWebFrame(blink::WebFrame* web_frame) {
   FrameMap::iterator iter = g_frame_map.Get().find(web_frame);
   if (iter != g_frame_map.Get().end())
     return iter->second;
   return NULL;
 }
 
 // static
 void RenderFrameImpl::InstallCreateHook(
     CreateRenderFrameImplFunction create_render_frame_impl) {
@@ skipping 178 matching lines @@
   if (parent_frame) {
     previews_state_ = parent_frame->GetPreviewsState();
     effective_connection_type_ = parent_frame->GetEffectiveConnectionType();
   }
 
   bool is_tracing_rail = false;
   bool is_tracing_navigation = false;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED("navigation", &is_tracing_navigation);
   TRACE_EVENT_CATEGORY_GROUP_ENABLED("rail", &is_tracing_rail);
   if (is_tracing_rail || is_tracing_navigation) {
-    int parent_id = GetRoutingIdForFrameOrProxy(frame_->Parent());
+    int parent_id = RenderFrame::GetRoutingIdForWebFrame(frame_->Parent());
     TRACE_EVENT2("navigation,rail", "RenderFrameImpl::Initialize",
                  "id", routing_id_,
                  "parent", parent_id);
   }
 
 #if BUILDFLAG(ENABLE_PLUGINS)
   new PepperBrowserConnection(this);
 #endif
   shared_worker_repository_ = base::MakeUnique<SharedWorkerRepository>(this);
   GetWebFrame()->SetSharedWorkerRepositoryClient(
@@ skipping 2031 matching lines @@
     bool is_potentially_trustworthy_unique_origin) {
   Send(new FrameHostMsg_UpdateToUniqueOrigin(
       routing_id_, is_potentially_trustworthy_unique_origin));
 }
 
 void RenderFrameImpl::DidChangeFramePolicy(
     blink::WebFrame* child_frame,
     blink::WebSandboxFlags flags,
     const blink::WebParsedFeaturePolicy& container_policy) {
   Send(new FrameHostMsg_DidChangeFramePolicy(
-      routing_id_, GetRoutingIdForFrameOrProxy(child_frame), flags,
+      routing_id_, RenderFrame::GetRoutingIdForWebFrame(child_frame), flags,
       FeaturePolicyHeaderFromWeb(container_policy)));
 }
 
 void RenderFrameImpl::DidSetFeaturePolicyHeader(
     const blink::WebParsedFeaturePolicy& parsed_header) {
   Send(new FrameHostMsg_DidSetFeaturePolicyHeader(
       routing_id_, FeaturePolicyHeaderFromWeb(parsed_header)));
 }
 
 void RenderFrameImpl::DidAddContentSecurityPolicies(
     const blink::WebVector<blink::WebContentSecurityPolicy>& policies) {
   std::vector<ContentSecurityPolicy> content_policies;
   for (const auto& policy : policies)
     content_policies.push_back(BuildContentSecurityPolicy(policy));
 
   Send(new FrameHostMsg_DidAddContentSecurityPolicies(routing_id_,
                                                       content_policies));
 }
 
 void RenderFrameImpl::DidChangeFrameOwnerProperties(
     blink::WebFrame* child_frame,
     const blink::WebFrameOwnerProperties& frame_owner_properties) {
   Send(new FrameHostMsg_DidChangeFrameOwnerProperties(
-      routing_id_, GetRoutingIdForFrameOrProxy(child_frame),
+      routing_id_, RenderFrame::GetRoutingIdForWebFrame(child_frame),
       ConvertWebFrameOwnerPropertiesToFrameOwnerProperties(
           frame_owner_properties)));
 }
 
 void RenderFrameImpl::DidMatchCSS(
     const blink::WebVector<blink::WebString>& newly_matching_selectors,
     const blink::WebVector<blink::WebString>& stopped_matching_selectors) {
   for (auto& observer : observers_)
     observer.DidMatchCSS(newly_matching_selectors, stopped_matching_selectors);
 }
@@ skipping 1051 matching lines @@
   // Add an empty HTTP origin header for non GET methods if none is currently
   // present.
   request.AddHTTPOriginIfNeeded(WebSecurityOrigin::CreateUnique());
 
   // Attach |should_replace_current_entry| state to requests so that, should
   // this navigation later require a request transfer, all state is preserved
   // when it is re-created in the new process.
   bool should_replace_current_entry = data_source->ReplacesCurrentHistoryItem();
 
   WebFrame* parent = frame_->Parent();
-  int parent_routing_id = parent ? GetRoutingIdForFrameOrProxy(parent) : -1;
+  int parent_routing_id =
+      parent ? RenderFrame::GetRoutingIdForWebFrame(parent) : -1;
 
   RequestExtraData* extra_data =
       static_cast<RequestExtraData*>(request.GetExtraData());
   if (!extra_data)
     extra_data = new RequestExtraData();
   extra_data->set_visibility_state(VisibilityState());
   extra_data->set_custom_user_agent(custom_user_agent);
   extra_data->set_requested_with(requested_with);
   extra_data->set_render_frame_id(routing_id_);
   extra_data->set_is_main_frame(!parent);
@@ skipping 2630 matching lines @@
       policy(info.default_policy),
       replaces_current_history_item(info.replaces_current_history_item),
       history_navigation_in_new_child_frame(
           info.is_history_navigation_in_new_child_frame),
       client_redirect(info.is_client_redirect),
       cache_disabled(info.is_cache_disabled),
       form(info.form),
       source_location(info.source_location) {}
 
 }  // namespace content