Give the main frame a RenderWidget.

content/browser/frame_host/frame_tree_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 "content/browser/frame_host/frame_tree.h"
 
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "content/browser/frame_host/navigator_impl.h"
 #include "content/browser/frame_host/render_frame_host_factory.h"
@@ skipping 118 matching lines @@
   FrameTreeNode* root = frame_tree->root();
 
   std::string no_children_node("no children node");
   std::string deep_subtree("node with deep subtree");
   int process_id = root->current_frame_host()->GetProcess()->GetID();
 
   // Do not navigate each frame separately, since that will clutter the test
   // itself. Instead, leave them in "not live" state, which is indicated by the
   // * after the frame id, since this test cares about the shape, not the
   // frame liveliness.
-  EXPECT_EQ("1*: []", GetTreeState(frame_tree));
+  EXPECT_EQ("2*: []", GetTreeState(frame_tree));
 
   // Simulate attaching a series of frames to build the frame tree.
   frame_tree->AddFrame(root, process_id, 14, blink::WebTreeScopeType::Document,
                        std::string(), blink::WebSandboxFlags::None);
   frame_tree->AddFrame(root, process_id, 15, blink::WebTreeScopeType::Document,
                        std::string(), blink::WebSandboxFlags::None);
   frame_tree->AddFrame(root, process_id, 16, blink::WebTreeScopeType::Document,
                        std::string(), blink::WebSandboxFlags::None);
 
   frame_tree->AddFrame(root->child_at(0), process_id, 244,
                        blink::WebTreeScopeType::Document, std::string(),
                        blink::WebSandboxFlags::None);
   frame_tree->AddFrame(root->child_at(1), process_id, 255,
                        blink::WebTreeScopeType::Document, no_children_node,
                        blink::WebSandboxFlags::None);
   frame_tree->AddFrame(root->child_at(0), process_id, 245,
                        blink::WebTreeScopeType::Document, std::string(),
                        blink::WebSandboxFlags::None);
 
-  EXPECT_EQ("1*: [14*: [244*: [], 245*: []], "
-                "15*: [255* 'no children node': []], "
-                "16*: []]",
-            GetTreeState(frame_tree));
+  EXPECT_EQ(
+      "2*: [14*: [244*: [], 245*: []], "
+      "15*: [255* 'no children node': []], "
+      "16*: []]",
+      GetTreeState(frame_tree));
 
   FrameTreeNode* child_16 = root->child_at(2);
   frame_tree->AddFrame(child_16, process_id, 264,
                        blink::WebTreeScopeType::Document, std::string(),
                        blink::WebSandboxFlags::None);
   frame_tree->AddFrame(child_16, process_id, 265,
                        blink::WebTreeScopeType::Document, std::string(),
                        blink::WebSandboxFlags::None);
   frame_tree->AddFrame(child_16, process_id, 266,
                        blink::WebTreeScopeType::Document, std::string(),
@@ skipping 13 matching lines @@
                        blink::WebTreeScopeType::Document, std::string(),
                        blink::WebSandboxFlags::None);
   frame_tree->AddFrame(child_267->child_at(0)->child_at(0), process_id, 555,
                        blink::WebTreeScopeType::Document, std::string(),
                        blink::WebSandboxFlags::None);
   frame_tree->AddFrame(child_267->child_at(0)->child_at(0)->child_at(0),
                        process_id, 655, blink::WebTreeScopeType::Document,
                        std::string(), blink::WebSandboxFlags::None);
 
   // Now that's it's fully built, verify the tree structure is as expected.
-  EXPECT_EQ("1*: [14*: [244*: [], 245*: []], "
-                "15*: [255* 'no children node': []], "
-                "16*: [264*: [], 265*: [], 266*: [], "
-                     "267* 'node with deep subtree': "
-                         "[365*: [455*: [555*: [655*: []]]]], 268*: []]]",
-            GetTreeState(frame_tree));
+  EXPECT_EQ(
+      "2*: [14*: [244*: [], 245*: []], "
+      "15*: [255* 'no children node': []], "
+      "16*: [264*: [], 265*: [], 266*: [], "
+      "267* 'node with deep subtree': "
+      "[365*: [455*: [555*: [655*: []]]]], 268*: []]]",
+      GetTreeState(frame_tree));
 
   FrameTreeNode* child_555 = child_267->child_at(0)->child_at(0)->child_at(0);
   frame_tree->RemoveFrame(child_555);
-  EXPECT_EQ("1*: [14*: [244*: [], 245*: []], "
-                "15*: [255* 'no children node': []], "
-                "16*: [264*: [], 265*: [], 266*: [], "
-                     "267* 'node with deep subtree': "
-                         "[365*: [455*: []]], 268*: []]]",
-            GetTreeState(frame_tree));
+  EXPECT_EQ(
+      "2*: [14*: [244*: [], 245*: []], "
+      "15*: [255* 'no children node': []], "
+      "16*: [264*: [], 265*: [], 266*: [], "
+      "267* 'node with deep subtree': "
+      "[365*: [455*: []]], 268*: []]]",
+      GetTreeState(frame_tree));
 
   frame_tree->RemoveFrame(child_16->child_at(1));
-  EXPECT_EQ("1*: [14*: [244*: [], 245*: []], "
-                "15*: [255* 'no children node': []], "
-                "16*: [264*: [], 266*: [], "
-                     "267* 'node with deep subtree': "
-                         "[365*: [455*: []]], 268*: []]]",
-            GetTreeState(frame_tree));
+  EXPECT_EQ(
+      "2*: [14*: [244*: [], 245*: []], "
+      "15*: [255* 'no children node': []], "
+      "16*: [264*: [], 266*: [], "
+      "267* 'node with deep subtree': "
+      "[365*: [455*: []]], 268*: []]]",
+      GetTreeState(frame_tree));
 
   frame_tree->RemoveFrame(root->child_at(1));
-  EXPECT_EQ("1*: [14*: [244*: [], 245*: []], "
-                "16*: [264*: [], 266*: [], "
-                     "267* 'node with deep subtree': "
-                         "[365*: [455*: []]], 268*: []]]",
-            GetTreeState(frame_tree));
+  EXPECT_EQ(
+      "2*: [14*: [244*: [], 245*: []], "
+      "16*: [264*: [], 266*: [], "
+      "267* 'node with deep subtree': "
+      "[365*: [455*: []]], 268*: []]]",
+      GetTreeState(frame_tree));
 }
 
 // Ensure frames can be found by frame_tree_node_id, routing ID, or name.
 TEST_F(FrameTreeTest, FindFrames) {
   main_test_rfh()->InitializeRenderFrameIfNeeded();
 
   // Add a few child frames to the main frame.
   FrameTree* frame_tree = contents()->GetFrameTree();
   FrameTreeNode* root = frame_tree->root();
 
@@ skipping 69 matching lines @@
   EXPECT_EQ(child0, child1->PreviousSibling());
   EXPECT_EQ(child1, child2->PreviousSibling());
   EXPECT_EQ(nullptr, grandchild->PreviousSibling());
 }
 
 // Do some simple manipulations of the frame tree, making sure that
 // WebContentsObservers see a consistent view of the tree as we go.
 TEST_F(FrameTreeTest, ObserverWalksTreeDuringFrameCreation) {
   TreeWalkingWebContentsLogger activity(contents());
   contents()->NavigateAndCommit(GURL("http://www.google.com"));
-  EXPECT_EQ("RenderFrameCreated(1) -> 1: []", activity.GetLog());
+  EXPECT_EQ("RenderFrameCreated(2) -> 2: []", activity.GetLog());
 
   FrameTree* frame_tree = contents()->GetFrameTree();
   FrameTreeNode* root = frame_tree->root();
 
   // Simulate attaching a series of frames to build the frame tree.
   main_test_rfh()->OnCreateChildFrame(14, blink::WebTreeScopeType::Document,
                                       std::string(),
                                       blink::WebSandboxFlags::None);
   EXPECT_EQ(
-      "RenderFrameHostChanged(new)(14) -> 1: []\n"
-      "RenderFrameCreated(14) -> 1: [14: []]",
+      "RenderFrameHostChanged(new)(14) -> 2: []\n"
+      "RenderFrameCreated(14) -> 2: [14: []]",
       activity.GetLog());
   main_test_rfh()->OnCreateChildFrame(18, blink::WebTreeScopeType::Document,
                                       std::string(),
                                       blink::WebSandboxFlags::None);
   EXPECT_EQ(
-      "RenderFrameHostChanged(new)(18) -> 1: [14: []]\n"
-      "RenderFrameCreated(18) -> 1: [14: [], 18: []]",
+      "RenderFrameHostChanged(new)(18) -> 2: [14: []]\n"
+      "RenderFrameCreated(18) -> 2: [14: [], 18: []]",
       activity.GetLog());
   frame_tree->RemoveFrame(root->child_at(0));
-  EXPECT_EQ("RenderFrameDeleted(14) -> 1: [18: []]", activity.GetLog());
+  EXPECT_EQ("RenderFrameDeleted(14) -> 2: [18: []]", activity.GetLog());
   frame_tree->RemoveFrame(root->child_at(0));
-  EXPECT_EQ("RenderFrameDeleted(18) -> 1: []", activity.GetLog());
+  EXPECT_EQ("RenderFrameDeleted(18) -> 2: []", activity.GetLog());
 }
 
 // Make sure that WebContentsObservers see a consistent view of the tree after
 // recovery from a render process crash.
 TEST_F(FrameTreeTest, ObserverWalksTreeAfterCrash) {
   TreeWalkingWebContentsLogger activity(contents());
   contents()->NavigateAndCommit(GURL("http://www.google.com"));
-  EXPECT_EQ("RenderFrameCreated(1) -> 1: []", activity.GetLog());
+  EXPECT_EQ("RenderFrameCreated(2) -> 2: []", activity.GetLog());
 
   main_test_rfh()->OnCreateChildFrame(22, blink::WebTreeScopeType::Document,
                                       std::string(),
                                       blink::WebSandboxFlags::None);
   EXPECT_EQ(
-      "RenderFrameHostChanged(new)(22) -> 1: []\n"
-      "RenderFrameCreated(22) -> 1: [22: []]",
+      "RenderFrameHostChanged(new)(22) -> 2: []\n"
+      "RenderFrameCreated(22) -> 2: [22: []]",
       activity.GetLog());
   main_test_rfh()->OnCreateChildFrame(23, blink::WebTreeScopeType::Document,
                                       std::string(),
                                       blink::WebSandboxFlags::None);
   EXPECT_EQ(
-      "RenderFrameHostChanged(new)(23) -> 1: [22: []]\n"
-      "RenderFrameCreated(23) -> 1: [22: [], 23: []]",
+      "RenderFrameHostChanged(new)(23) -> 2: [22: []]\n"
+      "RenderFrameCreated(23) -> 2: [22: [], 23: []]",
       activity.GetLog());
 
   // Crash the renderer
   main_test_rfh()->GetProcess()->SimulateCrash();
   EXPECT_EQ(
-      "RenderProcessGone -> 1*: [22*: [], 23*: []]\n"
-      "RenderFrameDeleted(23) -> 1*: [22*: [], 23*: []]\n"
-      "RenderFrameDeleted(22) -> 1*: [22*: [], 23*: []]\n"
-      "RenderFrameDeleted(1) -> 1*: []",
+      "RenderProcessGone -> 2*: [22*: [], 23*: []]\n"
+      "RenderFrameDeleted(23) -> 2*: [22*: [], 23*: []]\n"
+      "RenderFrameDeleted(22) -> 2*: [22*: [], 23*: []]\n"
+      "RenderFrameDeleted(2) -> 2*: []",
       activity.GetLog());
 }
 
 // Ensure that frames are not added to the tree, if the process passed in
 // is different than the process of the parent node.
 TEST_F(FrameTreeTest, FailAddFrameWithWrongProcessId) {
   contents()->NavigateAndCommit(GURL("http://www.google.com"));
   FrameTree* frame_tree = contents()->GetFrameTree();
   FrameTreeNode* root = frame_tree->root();
   int process_id = root->current_frame_host()->GetProcess()->GetID();
 
-  ASSERT_EQ("1: []", GetTreeState(frame_tree));
+  ASSERT_EQ("2: []", GetTreeState(frame_tree));
 
   // Simulate attaching a frame from mismatched process id.
   ASSERT_FALSE(frame_tree->AddFrame(
       root, process_id + 1, 1, blink::WebTreeScopeType::Document, std::string(),
       blink::WebSandboxFlags::None));
-  ASSERT_EQ("1: []", GetTreeState(frame_tree));
+  ASSERT_EQ("2: []", GetTreeState(frame_tree));
 }
 
 // Ensure that frames removed while a process has crashed are not preserved in
 // the global map of id->frame.
 TEST_F(FrameTreeTest, ProcessCrashClearsGlobalMap) {
   main_test_rfh()->InitializeRenderFrameIfNeeded();
 
   // Add a couple child frames to the main frame.
   FrameTreeNode* root = contents()->GetFrameTree()->root();
 
@@ skipping 20 matching lines @@
   // Crash the renderer.
   main_test_rfh()->GetProcess()->SimulateCrash();
 
   // Ensure they cannot be found by id after the process has crashed.
   EXPECT_FALSE(FrameTreeNode::GloballyFindByID(id1));
   EXPECT_FALSE(FrameTreeNode::GloballyFindByID(id2));
   EXPECT_FALSE(FrameTreeNode::GloballyFindByID(id3));
 }
 
 }  // namespace content