Add ASSERTs to WebFrameTest to ensure frame parameters are correct

third_party/WebKit/Source/web/tests/WebFrameTest.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 4431 matching lines @@
     bool Equals(Notification* other) {
       return other && frame == other->frame && context == other->context &&
              world_id == other->world_id;
     }
 
     WebLocalFrame* frame;
     v8::Persistent<v8::Context> context;
     int world_id;
   };
 
+  ContextLifetimeTestWebFrameClient(
+      Vector<std::unique_ptr<Notification>>& create_notifications,
+      Vector<std::unique_ptr<Notification>>& release_notifications)
+      : create_notifications_(create_notifications),
+        release_notifications_(release_notifications) {}
+
   ~ContextLifetimeTestWebFrameClient() override { Reset(); }
 
   void Reset() {
-    create_notifications.clear();
-    release_notifications.clear();
+    create_notifications_.clear();
+    release_notifications_.clear();
   }
 
-  Vector<std::unique_ptr<Notification>> create_notifications;
-  Vector<std::unique_ptr<Notification>> release_notifications;
+ private:
+  Vector<std::unique_ptr<Notification>>& create_notifications_;
+  Vector<std::unique_ptr<Notification>>& release_notifications_;
 
- private:
   void DidCreateScriptContext(WebLocalFrame* frame,
                               v8::Local<v8::Context> context,
                               int world_id) override {
-    create_notifications.push_back(
+    ASSERT_EQ(Frame(), frame);
+    create_notifications_.push_back(
         WTF::MakeUnique<Notification>(frame, context, world_id));
   }
 
   void WillReleaseScriptContext(WebLocalFrame* frame,
                                 v8::Local<v8::Context> context,
                                 int world_id) override {
-    release_notifications.push_back(
+    ASSERT_EQ(Frame(), frame);
+    release_notifications_.push_back(
         WTF::MakeUnique<Notification>(frame, context, world_id));
   }
 };
 
+class ContextLifetimeTestMainFrameClient
+    : public ContextLifetimeTestWebFrameClient {
+ public:
+  ContextLifetimeTestMainFrameClient(
+      Vector<std::unique_ptr<Notification>>& create_notifications,
+      Vector<std::unique_ptr<Notification>>& release_notifications)
+      : ContextLifetimeTestWebFrameClient(create_notifications,
+                                          release_notifications),
+        child_client_(create_notifications, release_notifications) {}
+
+  WebLocalFrame* CreateChildFrame(
+      WebLocalFrame* parent,
+      WebTreeScopeType scope,
+      const WebString& name,
+      const WebString& fallback_name,
+      WebSandboxFlags sandbox_flags,
+      const WebParsedFeaturePolicy& container_policy,
+      const WebFrameOwnerProperties&) override {
+    WebLocalFrame* frame =
+        WebLocalFrame::Create(scope, &child_client_, nullptr, nullptr);
+    child_client_.SetFrame(frame);
+    parent->AppendChild(frame);
+    return frame;
+  }
+
+  ContextLifetimeTestWebFrameClient& ChildClient() { return child_client_; }
+
+ private:
+  ContextLifetimeTestWebFrameClient child_client_;
+};
+
 TEST_P(ParameterizedWebFrameTest, ContextNotificationsLoadUnload) {
   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
 
   RegisterMockedHttpURLLoad("context_notifications_test.html");
   RegisterMockedHttpURLLoad("context_notifications_test_frame.html");
 
   // Load a frame with an iframe, make sure we get the right create
   // notifications.
-  ContextLifetimeTestWebFrameClient web_frame_client;
+  Vector<std::unique_ptr<ContextLifetimeTestWebFrameClient::Notification>>
+      create_notifications;
+  Vector<std::unique_ptr<ContextLifetimeTestWebFrameClient::Notification>>
+      release_notifications;
+  ContextLifetimeTestMainFrameClient web_frame_client(create_notifications,
+                                                      release_notifications);
   FrameTestHelpers::WebViewHelper web_view_helper;
   web_view_helper.InitializeAndLoad(
       base_url_ + "context_notifications_test.html", true, &web_frame_client);
 
   WebFrame* main_frame = web_view_helper.WebView()->MainFrame();
   WebFrame* child_frame = main_frame->FirstChild();
 
-  ASSERT_EQ(2u, web_frame_client.create_notifications.size());
-  EXPECT_EQ(0u, web_frame_client.release_notifications.size());
+  ASSERT_EQ(2u, create_notifications.size());
+  EXPECT_EQ(0u, release_notifications.size());
 
-  auto& first_create_notification = web_frame_client.create_notifications[0];
-  auto& second_create_notification = web_frame_client.create_notifications[1];
+  auto& first_create_notification = create_notifications[0];
+  auto& second_create_notification = create_notifications[1];
 
   EXPECT_EQ(main_frame, first_create_notification->frame);
   EXPECT_EQ(main_frame->MainWorldScriptContext(),
             first_create_notification->context);
   EXPECT_EQ(0, first_create_notification->world_id);
 
   EXPECT_EQ(child_frame, second_create_notification->frame);
   EXPECT_EQ(child_frame->MainWorldScriptContext(),
             second_create_notification->context);
   EXPECT_EQ(0, second_create_notification->world_id);
 
   // Close the view. We should get two release notifications that are exactly
   // the same as the create ones, in reverse order.
   web_view_helper.Reset();
 
-  ASSERT_EQ(2u, web_frame_client.release_notifications.size());
-  auto& first_release_notification = web_frame_client.release_notifications[0];
-  auto& second_release_notification = web_frame_client.release_notifications[1];
+  ASSERT_EQ(2u, release_notifications.size());
+  auto& first_release_notification = release_notifications[0];
+  auto& second_release_notification = release_notifications[1];
 
   ASSERT_TRUE(
       first_create_notification->Equals(second_release_notification.get()));
   ASSERT_TRUE(
       second_create_notification->Equals(first_release_notification.get()));
 }
 
 TEST_P(ParameterizedWebFrameTest, ContextNotificationsReload) {
   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
 
   RegisterMockedHttpURLLoad("context_notifications_test.html");
   RegisterMockedHttpURLLoad("context_notifications_test_frame.html");
 
-  ContextLifetimeTestWebFrameClient web_frame_client;
+  Vector<std::unique_ptr<ContextLifetimeTestWebFrameClient::Notification>>
+      create_notifications;
+  Vector<std::unique_ptr<ContextLifetimeTestWebFrameClient::Notification>>
+      release_notifications;
+  ContextLifetimeTestMainFrameClient web_frame_client(create_notifications,
+                                                      release_notifications);
   FrameTestHelpers::WebViewHelper web_view_helper;
   web_view_helper.InitializeAndLoad(
       base_url_ + "context_notifications_test.html", true, &web_frame_client);
 
   // Refresh, we should get two release notifications and two more create
   // notifications.
   FrameTestHelpers::ReloadFrame(web_view_helper.WebView()->MainFrame());
-  ASSERT_EQ(4u, web_frame_client.create_notifications.size());
-  ASSERT_EQ(2u, web_frame_client.release_notifications.size());
+  ASSERT_EQ(4u, create_notifications.size());
+  ASSERT_EQ(2u, release_notifications.size());
 
   // The two release notifications we got should be exactly the same as the
   // first two create notifications.
-  for (size_t i = 0; i < web_frame_client.release_notifications.size(); ++i) {
-    EXPECT_TRUE(web_frame_client.release_notifications[i]->Equals(
-        web_frame_client
-            .create_notifications[web_frame_client.create_notifications.size() -
-                                  3 - i]
-            .get()));
+  for (size_t i = 0; i < release_notifications.size(); ++i) {
+    EXPECT_TRUE(release_notifications[i]->Equals(
+        create_notifications[create_notifications.size() - 3 - i].get()));
   }
 
   // The last two create notifications should be for the current frames and
   // context.
   WebFrame* main_frame = web_view_helper.WebView()->MainFrame();
   WebFrame* child_frame = main_frame->FirstChild();
-  auto& first_refresh_notification = web_frame_client.create_notifications[2];
-  auto& second_refresh_notification = web_frame_client.create_notifications[3];
+  auto& first_refresh_notification = create_notifications[2];
+  auto& second_refresh_notification = create_notifications[3];
 
   EXPECT_EQ(main_frame, first_refresh_notification->frame);
   EXPECT_EQ(main_frame->MainWorldScriptContext(),
             first_refresh_notification->context);
   EXPECT_EQ(0, first_refresh_notification->world_id);
 
   EXPECT_EQ(child_frame, second_refresh_notification->frame);
   EXPECT_EQ(child_frame->MainWorldScriptContext(),
             second_refresh_notification->context);
   EXPECT_EQ(0, second_refresh_notification->world_id);
 }
 
 TEST_P(ParameterizedWebFrameTest, ContextNotificationsIsolatedWorlds) {
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   v8::HandleScope handle_scope(isolate);
 
   RegisterMockedHttpURLLoad("context_notifications_test.html");
   RegisterMockedHttpURLLoad("context_notifications_test_frame.html");
 
-  ContextLifetimeTestWebFrameClient web_frame_client;
+  Vector<std::unique_ptr<ContextLifetimeTestWebFrameClient::Notification>>
+      create_notifications;
+  Vector<std::unique_ptr<ContextLifetimeTestWebFrameClient::Notification>>
+      release_notifications;
+  ContextLifetimeTestMainFrameClient web_frame_client(create_notifications,
+                                                      release_notifications);
   FrameTestHelpers::WebViewHelper web_view_helper;
   web_view_helper.InitializeAndLoad(
       base_url_ + "context_notifications_test.html", true, &web_frame_client);
 
   // Add an isolated world.
   web_frame_client.Reset();
 
   int isolated_world_id = 42;
   WebScriptSource script_source("hi!");
   int num_sources = 1;
   web_view_helper.WebView()->MainFrame()->ExecuteScriptInIsolatedWorld(
       isolated_world_id, &script_source, num_sources);
 
   // We should now have a new create notification.
-  ASSERT_EQ(1u, web_frame_client.create_notifications.size());
-  auto& notification = web_frame_client.create_notifications[0];
+  ASSERT_EQ(1u, create_notifications.size());
+  auto& notification = create_notifications[0];
   ASSERT_EQ(isolated_world_id, notification->world_id);
   ASSERT_EQ(web_view_helper.WebView()->MainFrame(), notification->frame);
 
   // We don't have an API to enumarate isolated worlds for a frame, but we can
   // at least assert that the context we got is *not* the main world's context.
   ASSERT_NE(web_view_helper.WebView()->MainFrame()->MainWorldScriptContext(),
             v8::Local<v8::Context>::New(isolate, notification->context));
 
   web_view_helper.Reset();
 
   // We should have gotten three release notifications (one for each of the
   // frames, plus one for the isolated context).
-  ASSERT_EQ(3u, web_frame_client.release_notifications.size());
+  ASSERT_EQ(3u, release_notifications.size());
 
   // And one of them should be exactly the same as the create notification for
   // the isolated context.
   int match_count = 0;
-  for (size_t i = 0; i < web_frame_client.release_notifications.size(); ++i) {
-    if (web_frame_client.release_notifications[i]->Equals(
-            web_frame_client.create_notifications[0].get()))
+  for (size_t i = 0; i < release_notifications.size(); ++i) {
+    if (release_notifications[i]->Equals(create_notifications[0].get()))
       ++match_count;
   }
   EXPECT_EQ(1, match_count);
 }
 
 TEST_P(ParameterizedWebFrameTest, FindInPage) {
   RegisterMockedHttpURLLoad("find.html");
   FrameTestHelpers::WebViewHelper web_view_helper;
   web_view_helper.InitializeAndLoad(base_url_ + "find.html");
   ASSERT_TRUE(web_view_helper.WebView()->MainFrameImpl());
@@ skipping 7374 matching lines @@
 
   // Failing the original child frame navigation and trying to render fallback
   // content shouldn't crash. It should return NoLoadInProgress. This is so the
   // caller won't attempt to replace the correctly empty frame with an error
   // page.
   EXPECT_EQ(WebLocalFrame::NoLoadInProgress,
             child->MaybeRenderFallbackContent(WebURLError()));
 }
 
 }  // namespace blink