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

content/browser/frame_host/render_frame_host_manager_unittest.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 "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/histogram_tester.h"
 #include "base/time/time.h"
 #include "content/browser/compositor/test/no_transport_image_transport_factory.h"
@@ skipping 26 matching lines @@
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_notification_tracker.h"
 #include "content/public/test/test_utils.h"
 #include "content/test/test_content_browser_client.h"
 #include "content/test/test_content_client.h"
 #include "content/test/test_render_frame_host.h"
 #include "content/test/test_render_view_host.h"
 #include "content/test/test_web_contents.h"
 #include "net/base/load_flags.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/WebKit/public/web/WebFrameOwnerProperties.h"
 #include "third_party/WebKit/public/web/WebSandboxFlags.h"
 #include "ui/base/page_transition_types.h"
 
 namespace content {
 namespace {
 
 class RenderFrameHostManagerTestWebUIControllerFactory
     : public WebUIControllerFactory {
  public:
   RenderFrameHostManagerTestWebUIControllerFactory()
@@ skipping 619 matching lines @@
   }
 
   // Navigate to the first site.
   NavigateActiveAndCommit(kUrl1);
   TestRenderFrameHost* initial_rfh = contents()->GetMainFrame();
   {
     RenderFrameHostCreatedObserver observer(contents());
     initial_rfh->OnCreateChildFrame(
         initial_rfh->GetProcess()->GetNextRoutingID(),
         blink::WebTreeScopeType::Document, std::string(),
-        blink::WebSandboxFlags::None);
+        blink::WebSandboxFlags::None, blink::WebFrameOwnerProperties());
     EXPECT_TRUE(observer.created());
   }
 
   // Create one more frame in the same SiteInstance where initial_rfh
   // exists so that initial_rfh doesn't get deleted on navigation to another
   // site.
   initial_rfh->GetSiteInstance()->increment_active_frame_count();
 
   // Navigate to a cross-site URL.
   NavigateActiveAndCommit(kUrl2);
   EXPECT_TRUE(initial_rfh->is_swapped_out());
 
   TestRenderFrameHost* dest_rfh = contents()->GetMainFrame();
   ASSERT_TRUE(dest_rfh);
   EXPECT_NE(initial_rfh, dest_rfh);
 
   {
     // Since the old RFH is now swapped out, it shouldn't process any messages
     // to create child frames.
     RenderFrameHostCreatedObserver observer(contents());
     initial_rfh->OnCreateChildFrame(
         initial_rfh->GetProcess()->GetNextRoutingID(),
         blink::WebTreeScopeType::Document, std::string(),
-        blink::WebSandboxFlags::None);
+        blink::WebSandboxFlags::None, blink::WebFrameOwnerProperties());
     EXPECT_FALSE(observer.created());
   }
 }
 
 TEST_F(RenderFrameHostManagerTest, WhiteListSwapCompositorFrame) {
   // TODO(nasko): Check with kenrb whether this test can be rewritten and
   // whether it makes sense when swapped out is replaced with proxies.
   if (SiteIsolationPolicy::IsSwappedOutStateForbidden()) {
     return;
   }
@@ skipping 1346 matching lines @@
   IsolateAllSitesForTesting(base::CommandLine::ForCurrentProcess());
 
   const GURL kUrlA("http://www.google.com/");
   const GURL kUrlB("http://webkit.org/");
 
   // Create a page with two child frames.
   contents()->NavigateAndCommit(kUrlA);
   contents()->GetMainFrame()->OnCreateChildFrame(
       contents()->GetMainFrame()->GetProcess()->GetNextRoutingID(),
       blink::WebTreeScopeType::Document, "frame_name",
-      blink::WebSandboxFlags::None);
+      blink::WebSandboxFlags::None, blink::WebFrameOwnerProperties());
   contents()->GetMainFrame()->OnCreateChildFrame(
       contents()->GetMainFrame()->GetProcess()->GetNextRoutingID(),
       blink::WebTreeScopeType::Document, "frame_name",
-      blink::WebSandboxFlags::None);
+      blink::WebSandboxFlags::None, blink::WebFrameOwnerProperties());
   RenderFrameHostManager* root_manager =
       contents()->GetFrameTree()->root()->render_manager();
   RenderFrameHostManager* iframe1 =
       contents()->GetFrameTree()->root()->child_at(0)->render_manager();
   RenderFrameHostManager* iframe2 =
       contents()->GetFrameTree()->root()->child_at(1)->render_manager();
 
   // 1) The first navigation.
   NavigationEntryImpl entryA(NULL /* instance */, -1 /* page_id */, kUrlA,
                              Referrer(), base::string16() /* title */,
@@ skipping 117 matching lines @@
   // Reload |contents1|.
   contents1->NavigateAndCommit(kUrl1);
   EXPECT_TRUE(contents1->GetMainFrame()->IsRenderFrameLive());
   EXPECT_FALSE(contents2->GetMainFrame()->IsRenderFrameLive());
   EXPECT_EQ(contents1->GetSiteInstance(), contents2->GetSiteInstance());
 
   // |contents1| creates an out of process iframe.
   contents1->GetMainFrame()->OnCreateChildFrame(
       contents1->GetMainFrame()->GetProcess()->GetNextRoutingID(),
       blink::WebTreeScopeType::Document, "frame_name",
-      blink::WebSandboxFlags::None);
+      blink::WebSandboxFlags::None, blink::WebFrameOwnerProperties());
   RenderFrameHostManager* iframe =
       contents()->GetFrameTree()->root()->child_at(0)->render_manager();
   NavigationEntryImpl entry(NULL /* instance */, -1 /* page_id */, kUrl2,
                             Referrer(kUrl1, blink::WebReferrerPolicyDefault),
                             base::string16() /* title */,
                             ui::PAGE_TRANSITION_LINK,
                             false /* is_renderer_init */);
   RenderFrameHostImpl* cross_site = NavigateToEntry(iframe, entry);
   iframe->DidNavigateFrame(cross_site, true);
 
@@ skipping 139 matching lines @@
 // The test starts traversing openers from root1 and expects to discover all
 // four FrameTrees.  Nodes 13 (with cycle to itself) and 42 (with back link to
 // root3) should be put on the list of nodes that will need their frame openers
 // set separately in a second pass, since their opener routing IDs won't be
 // available during the first pass of CreateOpenerProxies.
 TEST_F(RenderFrameHostManagerTest, TraverseComplexOpenerChain) {
   FrameTree* tree1 = contents()->GetFrameTree();
   FrameTreeNode* root1 = tree1->root();
   int process_id = root1->current_frame_host()->GetProcess()->GetID();
   tree1->AddFrame(root1, process_id, 12, blink::WebTreeScopeType::Document,
-                  std::string(), blink::WebSandboxFlags::None);
+                  std::string(), blink::WebSandboxFlags::None,
+                  blink::WebFrameOwnerProperties());
   tree1->AddFrame(root1, process_id, 13, blink::WebTreeScopeType::Document,
-                  std::string(), blink::WebSandboxFlags::None);
+                  std::string(), blink::WebSandboxFlags::None,
+                  blink::WebFrameOwnerProperties());
 
   scoped_ptr<TestWebContents> tab2(
       TestWebContents::Create(browser_context(), nullptr));
   FrameTree* tree2 = tab2->GetFrameTree();
   FrameTreeNode* root2 = tree2->root();
   process_id = root2->current_frame_host()->GetProcess()->GetID();
   tree2->AddFrame(root2, process_id, 22, blink::WebTreeScopeType::Document,
-                  std::string(), blink::WebSandboxFlags::None);
+                  std::string(), blink::WebSandboxFlags::None,
+                  blink::WebFrameOwnerProperties());
   tree2->AddFrame(root2, process_id, 23, blink::WebTreeScopeType::Document,
-                  std::string(), blink::WebSandboxFlags::None);
+                  std::string(), blink::WebSandboxFlags::None,
+                  blink::WebFrameOwnerProperties());
 
   scoped_ptr<TestWebContents> tab3(
       TestWebContents::Create(browser_context(), nullptr));
   FrameTree* tree3 = tab3->GetFrameTree();
   FrameTreeNode* root3 = tree3->root();
 
   scoped_ptr<TestWebContents> tab4(
       TestWebContents::Create(browser_context(), nullptr));
   FrameTree* tree4 = tab4->GetFrameTree();
   FrameTreeNode* root4 = tree4->root();
   process_id = root4->current_frame_host()->GetProcess()->GetID();
   tree4->AddFrame(root4, process_id, 42, blink::WebTreeScopeType::Document,
-                  std::string(), blink::WebSandboxFlags::None);
+                  std::string(), blink::WebSandboxFlags::None,
+                  blink::WebFrameOwnerProperties());
 
   root1->child_at(1)->SetOpener(root1->child_at(1));
   root1->SetOpener(root2->child_at(1));
   root2->SetOpener(root3);
   root2->child_at(0)->SetOpener(root4);
   root2->child_at(1)->SetOpener(root4);
   root4->child_at(0)->SetOpener(root3);
 
   std::vector<FrameTree*> opener_frame_trees;
   base::hash_set<FrameTreeNode*> nodes_with_back_links;
 
   CollectOpenerFrameTrees(root1, &opener_frame_trees, &nodes_with_back_links);
 
   EXPECT_EQ(4U, opener_frame_trees.size());
   EXPECT_EQ(tree1, opener_frame_trees[0]);
   EXPECT_EQ(tree2, opener_frame_trees[1]);
   EXPECT_EQ(tree3, opener_frame_trees[2]);
   EXPECT_EQ(tree4, opener_frame_trees[3]);
 
   EXPECT_EQ(2U, nodes_with_back_links.size());
   EXPECT_TRUE(nodes_with_back_links.find(root1->child_at(1)) !=
               nodes_with_back_links.end());
   EXPECT_TRUE(nodes_with_back_links.find(root4->child_at(0)) !=
               nodes_with_back_links.end());
 }
 
 }  // namespace content