Add 'NavigationHandle::QueueConsoleMessage'.

content/browser/frame_host/navigation_handle_impl_unittest.cc

 // Copyright 2015 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/macros.h"
 #include "content/browser/frame_host/navigation_handle_impl.h"
 #include "content/public/browser/navigation_throttle.h"
 #include "content/test/test_render_frame_host.h"
 
 namespace content {
@@ skipping 38 matching lines @@
  private:
   // The result returned by the TestNavigationThrottle.
   NavigationThrottle::ThrottleCheckResult result_;
 
   // The number of times each handler was called.
   int will_start_calls_;
   int will_redirect_calls_;
   int will_process_response_calls_;
 };
 
+// A NavigationThrottle which adds console messages in WillStartRequest,
+// WillRedirectRequest, and always returns PROCEED.
+class TestConsoleMessagesThrottle : public NavigationThrottle {
+ public:
+  TestConsoleMessagesThrottle(NavigationHandle* handle)
+      : NavigationThrottle(handle) {}
+
+  ~TestConsoleMessagesThrottle() override {}
+
+  NavigationThrottle::ThrottleCheckResult WillStartRequest() override {
+    navigation_handle()->QueueConsoleMessage(CONSOLE_MESSAGE_LEVEL_LOG,
+                                             "WillStartRequest");
+    return NavigationThrottle::PROCEED;
+  }
+
+  NavigationThrottle::ThrottleCheckResult WillRedirectRequest() override {
+    navigation_handle()->QueueConsoleMessage(CONSOLE_MESSAGE_LEVEL_LOG,
+                                             "WillRedirectRequest");
+    return NavigationThrottle::PROCEED;
+  }
+
+  NavigationThrottle::ThrottleCheckResult WillProcessResponse() override {
+    navigation_handle()->QueueConsoleMessage(CONSOLE_MESSAGE_LEVEL_LOG,
+                                             "WillProcessResponse");
+    return NavigationThrottle::PROCEED;
+  }
+};
+
 class NavigationHandleImplTest : public RenderViewHostImplTestHarness {
  public:
   NavigationHandleImplTest()
       : was_callback_called_(false),
         callback_result_(NavigationThrottle::DEFER) {}
 
   void SetUp() override {
     RenderViewHostImplTestHarness::SetUp();
     test_handle_ = NavigationHandleImpl::Create(
         GURL(), main_test_rfh()->frame_tree_node(), true, false, false,
@@ skipping 16 matching lines @@
   }
 
   bool IsDeferringResponse() {
     return test_handle_->state() == NavigationHandleImpl::DEFERRING_RESPONSE;
   }
 
   bool IsCanceling() {
     return test_handle_->state() == NavigationHandleImpl::CANCELING;
   }
 
+  const std::queue<std::pair<ConsoleMessageLevel, const std::string>>&
+  GetConsoleQueue() const {
+    return test_handle_->console_queue_;
+  }
+
   // Helper function to call WillStartRequest on |handle|. If this function
   // returns DEFER, |callback_result_| will be set to the actual result of
   // the throttle checks when they are finished.
   void SimulateWillStartRequest() {
     was_callback_called_ = false;
     callback_result_ = NavigationThrottle::DEFER;
 
     // It's safe to use base::Unretained since the NavigationHandle is owned by
     // the NavigationHandleImplTest.
     test_handle_->WillStartRequest(
@@ skipping 52 matching lines @@
   // |result| on checks.
   TestNavigationThrottle* CreateTestNavigationThrottle(
       NavigationThrottle::ThrottleCheckResult result) {
     TestNavigationThrottle* test_throttle =
         new TestNavigationThrottle(test_handle(), result);
     test_handle()->RegisterThrottleForTesting(
         std::unique_ptr<TestNavigationThrottle>(test_throttle));
     return test_throttle;
   }
 
+  // Creates, register and returns a TestConsoleMessagesThrottle.
+  TestConsoleMessagesThrottle* CreateTestConsoleMessagesThrottle() {
+    TestConsoleMessagesThrottle* test_throttle =
+        new TestConsoleMessagesThrottle(test_handle());
+    test_handle()->RegisterThrottleForTesting(
+        std::unique_ptr<TestConsoleMessagesThrottle>(test_throttle));
+    return test_throttle;
+  }
+
  private:
   // The callback provided to NavigationHandleImpl::WillStartRequest and
   // NavigationHandleImpl::WillRedirectRequest during the tests.
   void UpdateThrottleCheckResult(
       NavigationThrottle::ThrottleCheckResult result) {
     callback_result_ = result;
     was_callback_called_ = true;
   }
 
   std::unique_ptr<NavigationHandleImpl> test_handle_;
@@ skipping 461 matching lines @@
   EXPECT_TRUE(was_callback_called());
   EXPECT_EQ(NavigationThrottle::CANCEL_AND_IGNORE, callback_result());
   EXPECT_EQ(0, cancel_throttle->will_start_calls());
   EXPECT_EQ(0, cancel_throttle->will_redirect_calls());
   EXPECT_EQ(1, cancel_throttle->will_process_response_calls());
   EXPECT_EQ(0, proceed_throttle->will_start_calls());
   EXPECT_EQ(0, proceed_throttle->will_redirect_calls());
   EXPECT_EQ(0, proceed_throttle->will_process_response_calls());
 }
 
+TEST_F(NavigationHandleImplTest, ConsoleMessages) {
+  TestConsoleMessagesThrottle* throttle = CreateTestConsoleMessagesThrottle();
+  DCHECK(throttle);
+  SimulateWillStartRequest();
+  DCHECK_EQ(1u, GetConsoleQueue().size());
+  DCHECK_EQ("WillStartRequest", GetConsoleQueue().back().second);
+
+  SimulateWillRedirectRequest();
+  DCHECK_EQ(2u, GetConsoleQueue().size());
+  DCHECK_EQ("WillRedirectRequest", GetConsoleQueue().back().second);
+
+  SimulateWillProcessResponse();
+  // Calling 'WillProcessResponse' should dump the queue.
+  DCHECK_EQ(0u, GetConsoleQueue().size());
+
+  // Verify that messages got to the RFH correctly.
+  DCHECK_EQ(3u, main_test_rfh()->GetConsoleMessages().size());
+  DCHECK_EQ("WillStartRequest", main_test_rfh()->GetConsoleMessages()[0]);
+  DCHECK_EQ("WillRedirectRequest", main_test_rfh()->GetConsoleMessages()[1]);
+  DCHECK_EQ("WillProcessResponse", main_test_rfh()->GetConsoleMessages()[2]);
+}
+
 }  // namespace content