Propagate scrolling/marginwidth/marginheight property values to child frame.

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 233 matching lines @@
 using blink::WebUserGestureIndicator;
 using blink::WebVector;
 using blink::WebView;
 using base::Time;
 using base::TimeDelta;
 
 namespace content {
 
 namespace {
 
+int GetRoutingIDForFrame(blink::WebFrame* frame) {

[alexmos, 2015/10/09 21:55:49]

Heads up: you don't need this anymore, as Nick has just landed a helper that you
can use: https://codereview.chromium.org/1398443004/

[lazyboy, 2015/10/13 21:59:08]

Done.

+  if (frame->isWebRemoteFrame())
+    return RenderFrameProxy::FromWebFrame(frame)->routing_id();
+
+  return RenderFrameImpl::FromWebFrame(frame)->GetRoutingID();
+}
+
 const char kDefaultAcceptHeader[] =
     "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/"
     "*;q=0.8";
 const char kAcceptHeader[] = "Accept";
 
 const size_t kExtraCharsBeforeAndAfterSelection = 100;
 
 typedef std::map<int, RenderFrameImpl*> RoutingIDFrameMap;
 static base::LazyInstance<RoutingIDFrameMap> g_routing_id_frame_map =
     LAZY_INSTANCE_INITIALIZER;
@@ skipping 296 matching lines @@
 
 // static
 void RenderFrameImpl::CreateFrame(
     int routing_id,
     int proxy_routing_id,
     int opener_routing_id,
     int parent_routing_id,
     int previous_sibling_routing_id,
     const FrameReplicationState& replicated_state,
     CompositorDependencies* compositor_deps,
-    const FrameMsg_NewFrame_WidgetParams& widget_params) {
+    const FrameMsg_NewFrame_WidgetParams& widget_params,
+    const blink::WebFrameOwnerProperties& frame_owner_properties) {
   blink::WebLocalFrame* web_frame;
   RenderFrameImpl* render_frame;
   if (proxy_routing_id == MSG_ROUTING_NONE) {
     RenderFrameProxy* parent_proxy =
         RenderFrameProxy::FromRoutingID(parent_routing_id);
     // If the browser is sending a valid parent routing id, it should already
     // be created and registered.
     CHECK(parent_proxy);
     blink::WebRemoteFrame* parent_web_frame = parent_proxy->web_frame();
 
     blink::WebFrame* previous_sibling_web_frame = nullptr;
     RenderFrameProxy* previous_sibling_proxy =
         RenderFrameProxy::FromRoutingID(previous_sibling_routing_id);
     if (previous_sibling_proxy)
       previous_sibling_web_frame = previous_sibling_proxy->web_frame();
 
     // Create the RenderFrame and WebLocalFrame, linking the two.
     render_frame =
         RenderFrameImpl::Create(parent_proxy->render_view(), routing_id);
     web_frame = parent_web_frame->createLocalChild(
         replicated_state.scope, WebString::fromUTF8(replicated_state.name),
         replicated_state.sandbox_flags, render_frame,
-        previous_sibling_web_frame);
+        previous_sibling_web_frame, frame_owner_properties);
   } else {
     RenderFrameProxy* proxy =
         RenderFrameProxy::FromRoutingID(proxy_routing_id);
     CHECK(proxy);
     render_frame = RenderFrameImpl::Create(proxy->render_view(), routing_id);
     web_frame =
         blink::WebLocalFrame::create(replicated_state.scope, render_frame);
     render_frame->proxy_routing_id_ = proxy_routing_id;
     web_frame->initializeToReplaceRemoteFrame(
         proxy->web_frame(), WebString::fromUTF8(replicated_state.name),
-        replicated_state.sandbox_flags);
+        replicated_state.sandbox_flags, frame_owner_properties);
   }
   render_frame->SetWebFrame(web_frame);
   CHECK_IMPLIES(parent_routing_id == MSG_ROUTING_NONE, !web_frame->parent());
 
   WebFrame* opener = ResolveOpener(opener_routing_id, nullptr);
   web_frame->setOpener(opener);
 
   if (widget_params.routing_id != MSG_ROUTING_NONE) {
     CHECK(SiteIsolationPolicy::AreCrossProcessFramesPossible());
     render_frame->render_widget_ = RenderWidget::CreateForFrame(
@@ skipping 504 matching lines @@
     IPC_MESSAGE_HANDLER(FrameMsg_Reload, OnReload)
     IPC_MESSAGE_HANDLER(FrameMsg_TextSurroundingSelectionRequest,
                         OnTextSurroundingSelectionRequest)
     IPC_MESSAGE_HANDLER(FrameMsg_SetAccessibilityMode,
                         OnSetAccessibilityMode)
     IPC_MESSAGE_HANDLER(AccessibilityMsg_SnapshotTree,
                         OnSnapshotAccessibilityTree)
     IPC_MESSAGE_HANDLER(FrameMsg_UpdateOpener, OnUpdateOpener)
     IPC_MESSAGE_HANDLER(FrameMsg_CommitNavigation, OnCommitNavigation)
     IPC_MESSAGE_HANDLER(FrameMsg_DidUpdateSandboxFlags, OnDidUpdateSandboxFlags)
+    IPC_MESSAGE_HANDLER(FrameMsg_SetFrameOwnerProperties,
+                        OnSetFrameOwnerProperties)
     IPC_MESSAGE_HANDLER(FrameMsg_ClearFocus, OnClearFocus)
     IPC_MESSAGE_HANDLER(FrameMsg_SetTextTrackSettings,
                         OnTextTrackSettingsChanged)
     IPC_MESSAGE_HANDLER(FrameMsg_PostMessageEvent, OnPostMessageEvent)
     IPC_MESSAGE_HANDLER(FrameMsg_FailedNavigation, OnFailedNavigation)
     IPC_MESSAGE_HANDLER(FrameMsg_GetSavableResourceLinks,
                         OnGetSavableResourceLinks)
     IPC_MESSAGE_HANDLER(FrameMsg_GetSerializedHtmlWithLocalLinks,
                         OnGetSerializedHtmlWithLocalLinks)
 #if defined(OS_ANDROID)
@@ skipping 537 matching lines @@
 
 void RenderFrameImpl::OnUpdateOpener(int opener_routing_id) {
   WebFrame* opener = ResolveOpener(opener_routing_id, nullptr);
   frame_->setOpener(opener);
 }
 
 void RenderFrameImpl::OnDidUpdateSandboxFlags(blink::WebSandboxFlags flags) {
   frame_->setFrameOwnerSandboxFlags(flags);
 }
 
+void RenderFrameImpl::OnSetFrameOwnerProperties(
+    const blink::WebFrameOwnerProperties& frame_owner_properties) {
+  DCHECK(frame_);
+  frame_->setFrameOwnerProperties(frame_owner_properties);
+}
+
 void RenderFrameImpl::OnClearFocus() {
   frame_->clearFocus();
 }
 
 void RenderFrameImpl::OnTextTrackSettingsChanged(
     const FrameMsg_TextTrackSettings_Params& params) {
   DCHECK(!frame_->parent());
   if (!render_view_->webview())
     return;
 
@@ skipping 512 matching lines @@
     if (!navigation_state->request_committed()) {
       Send(new FrameHostMsg_DidAccessInitialDocument(routing_id_));
     }
   }
 }
 
 blink::WebFrame* RenderFrameImpl::createChildFrame(
     blink::WebLocalFrame* parent,
     blink::WebTreeScopeType scope,
     const blink::WebString& name,
-    blink::WebSandboxFlags sandbox_flags) {
+    blink::WebSandboxFlags sandbox_flags,
+    const blink::WebFrameOwnerProperties& frameOwnerProperties) {
   // Synchronously notify the browser of a child frame creation to get the
   // routing_id for the RenderFrame.
   int child_routing_id = MSG_ROUTING_NONE;
   Send(new FrameHostMsg_CreateChildFrame(
-      routing_id_, scope,
-      base::UTF16ToUTF8(base::StringPiece16(name)), sandbox_flags,
-      &child_routing_id));
+      routing_id_, scope, base::UTF16ToUTF8(base::StringPiece16(name)),
+      sandbox_flags, frameOwnerProperties, &child_routing_id));
 
   // Allocation of routing id failed, so we can't create a child frame. This can
   // happen if this RenderFrameImpl's IPCs are being filtered when in swapped
   // out state or synchronous IPC message above has failed.
   if (child_routing_id == MSG_ROUTING_NONE) {
     NOTREACHED() << "Failed to allocate routing id for child frame.";
     return nullptr;
   }
 
   // This method is always called by local frames, never remote frames.
@@ skipping 110 matching lines @@
   // updates are happening too frequently.
   if (SiteIsolationPolicy::AreCrossProcessFramesPossible() ||
       render_view_->renderer_preferences_.report_frame_name_changes) {
     Send(new FrameHostMsg_DidChangeName(
         routing_id_, base::UTF16ToUTF8(base::StringPiece16(name))));
   }
 }
 
 void RenderFrameImpl::didChangeSandboxFlags(blink::WebFrame* child_frame,
                                             blink::WebSandboxFlags flags) {
-  int frame_routing_id = MSG_ROUTING_NONE;
-  if (child_frame->isWebRemoteFrame()) {
-    frame_routing_id =
-        RenderFrameProxy::FromWebFrame(child_frame)->routing_id();
-  } else {
-    frame_routing_id =
-        RenderFrameImpl::FromWebFrame(child_frame)->GetRoutingID();
-  }
-
+  int frame_routing_id = GetRoutingIDForFrame(child_frame);
   Send(new FrameHostMsg_DidChangeSandboxFlags(routing_id_, frame_routing_id,
                                               flags));
 }
 
+void RenderFrameImpl::didChangeFrameOwnerProperties(
+    blink::WebFrame* child_frame,
+    const blink::WebFrameOwnerProperties& frame_owner_properties) {
+  int frame_routing_id = GetRoutingIDForFrame(child_frame);
+  Send(new FrameHostMsg_DidChangeFrameOwnerProperties(
+           routing_id_, frame_routing_id, frame_owner_properties));
+}
+
 void RenderFrameImpl::didMatchCSS(
     blink::WebLocalFrame* frame,
     const blink::WebVector<blink::WebString>& newly_matching_selectors,
     const blink::WebVector<blink::WebString>& stopped_matching_selectors) {
   DCHECK(!frame_ || frame_ == frame);
 
   FOR_EACH_OBSERVER(RenderFrameObserver, observers_,
                     DidMatchCSS(newly_matching_selectors,
                                 stopped_matching_selectors));
 }
@@ skipping 2835 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