Use ScopedTaskEnvironment instead of MessageLoop in RenderViewTest.

content/renderer/render_frame_impl_browsertest.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 <stdint.h>
 
 #include "base/command_line.h"
 #include "base/debug/leak_annotations.h"
+#include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
 #include "content/child/web_url_loader_impl.h"
 #include "content/common/frame_messages.h"
 #include "content/common/frame_owner_properties.h"
 #include "content/common/renderer.mojom.h"
 #include "content/common/view_messages.h"
 #include "content/public/common/previews_state.h"
 #include "content/public/renderer/document_state.h"
 #include "content/public/test/frame_load_waiter.h"
@@ skipping 276 matching lines @@
 TEST_F(RenderFrameImplTest, SaveImageFromDataURL) {
   const IPC::Message* msg1 = render_thread_->sink().GetFirstMessageMatching(
       FrameHostMsg_SaveImageFromDataURL::ID);
   EXPECT_FALSE(msg1);
   render_thread_->sink().ClearMessages();
 
   const std::string image_data_url =
       "data:image/gif;base64,R0lGODlhAQABAIAAAAUEBAAAACwAAAAAAQABAAACAkQBADs=";
 
   frame()->SaveImageFromDataURL(WebString::FromUTF8(image_data_url));
-  ProcessPendingMessages();
+  base::RunLoop().RunUntilIdle();
   const IPC::Message* msg2 = render_thread_->sink().GetFirstMessageMatching(
       FrameHostMsg_SaveImageFromDataURL::ID);
   EXPECT_TRUE(msg2);
 
   FrameHostMsg_SaveImageFromDataURL::Param param1;
   FrameHostMsg_SaveImageFromDataURL::Read(msg2, &param1);
   EXPECT_EQ(std::get<2>(param1), image_data_url);
 
-  ProcessPendingMessages();
+  base::RunLoop().RunUntilIdle();
   render_thread_->sink().ClearMessages();
 
   const std::string large_data_url(1024 * 1024 * 20 - 1, 'd');
 
   frame()->SaveImageFromDataURL(WebString::FromUTF8(large_data_url));
-  ProcessPendingMessages();
+  base::RunLoop().RunUntilIdle();
   const IPC::Message* msg3 = render_thread_->sink().GetFirstMessageMatching(
       FrameHostMsg_SaveImageFromDataURL::ID);
   EXPECT_TRUE(msg3);
 
   FrameHostMsg_SaveImageFromDataURL::Param param2;
   FrameHostMsg_SaveImageFromDataURL::Read(msg3, &param2);
   EXPECT_EQ(std::get<2>(param2), large_data_url);
 
-  ProcessPendingMessages();
+  base::RunLoop().RunUntilIdle();
   render_thread_->sink().ClearMessages();
 
   const std::string exceeded_data_url(1024 * 1024 * 20 + 1, 'd');
 
   frame()->SaveImageFromDataURL(WebString::FromUTF8(exceeded_data_url));
-  ProcessPendingMessages();
+  base::RunLoop().RunUntilIdle();
   const IPC::Message* msg4 = render_thread_->sink().GetFirstMessageMatching(
       FrameHostMsg_SaveImageFromDataURL::ID);
   EXPECT_FALSE(msg4);
 }
 
 TEST_F(RenderFrameImplTest, ZoomLimit) {
   const double kMinZoomLevel = ZoomFactorToZoomLevel(kMinimumZoomFactor);
   const double kMaxZoomLevel = ZoomFactorToZoomLevel(kMaximumZoomFactor);
 
   // Verifies navigation to a URL with preset zoom level indeed sets the level.
   // Regression test for http://crbug.com/139559, where the level was not
   // properly set when it is out of the default zoom limits of WebView.
   CommonNavigationParams common_params;
   common_params.url = GURL("data:text/html,min_zoomlimit_test");
   common_params.navigation_type = FrameMsg_Navigate_Type::DIFFERENT_DOCUMENT;
   GetMainRenderFrame()->SetHostZoomLevel(common_params.url, kMinZoomLevel);
   GetMainRenderFrame()->NavigateInternal(
       common_params, StartNavigationParams(), RequestNavigationParams(),
       std::unique_ptr<StreamOverrideParameters>());
-  ProcessPendingMessages();
+  base::RunLoop().RunUntilIdle();
   EXPECT_DOUBLE_EQ(kMinZoomLevel, view_->GetWebView()->ZoomLevel());
 
   // It should work even when the zoom limit is temporarily changed in the page.
   view_->GetWebView()->ZoomLimitsChanged(ZoomFactorToZoomLevel(1.0),
                                          ZoomFactorToZoomLevel(1.0));
   common_params.url = GURL("data:text/html,max_zoomlimit_test");
   GetMainRenderFrame()->SetHostZoomLevel(common_params.url, kMaxZoomLevel);
   GetMainRenderFrame()->NavigateInternal(
       common_params, StartNavigationParams(), RequestNavigationParams(),
       std::unique_ptr<StreamOverrideParameters>());
-  ProcessPendingMessages();
+  base::RunLoop().RunUntilIdle();
   EXPECT_DOUBLE_EQ(kMaxZoomLevel, view_->GetWebView()->ZoomLevel());
 }
 
 // Regression test for crbug.com/692557. It shouldn't crash if we inititate a
 // text finding, and then delete the frame immediately before the text finding
 // returns any text match.
 TEST_F(RenderFrameImplTest, NoCrashWhenDeletingFrameDuringFind) {
   blink::WebFindOptions options;
   options.force = true;
   FrameMsg_Find find_message(0, 1, base::ASCIIToUTF16("foo"), options);
@@ skipping 16 matching lines @@
   // The host should receive a request for it sent to the frame.
   const IPC::Message* msg = render_thread_->sink().GetFirstMessageMatching(
       FrameHostMsg_RequestOverlayRoutingToken::ID);
   EXPECT_TRUE(msg);
 
   // Send a token.
   base::UnguessableToken token = base::UnguessableToken::Create();
   FrameMsg_SetOverlayRoutingToken token_message(0, token);
   frame()->OnMessageReceived(token_message);
 
-  ProcessPendingMessages();
+  base::RunLoop().RunUntilIdle();
   ASSERT_TRUE(overlay_routing_token_.has_value());
   ASSERT_EQ(overlay_routing_token_.value(), token);
 }
 
 // Verify that RFI sends tokens if they're already available.
 TEST_F(RenderFrameImplTest, TestOverlayRoutingTokenSendsNow) {
   ASSERT_FALSE(overlay_routing_token_.has_value());
   base::UnguessableToken token = base::UnguessableToken::Create();
   FrameMsg_SetOverlayRoutingToken token_message(0, token);
   frame()->OnMessageReceived(token_message);
 
   // The frame now has a token.  We don't care if it sends the token before
   // returning or posts a message.
-  ProcessPendingMessages();
+  base::RunLoop().RunUntilIdle();
   frame()->RequestOverlayRoutingToken(
       base::Bind(&RenderFrameImplTest::ReceiveOverlayRoutingToken,
                  base::Unretained(this)));
   ASSERT_TRUE(overlay_routing_token_.has_value());
   ASSERT_EQ(overlay_routing_token_.value(), token);
 
   // Since the token already arrived, a request for it shouldn't be sent.
   const IPC::Message* msg = render_thread_->sink().GetFirstMessageMatching(
       FrameHostMsg_RequestOverlayRoutingToken::ID);
   EXPECT_FALSE(msg);
@@ skipping 112 matching lines @@
         GURL(test.is_https ? "https://example.com" : "http://example.com"));
     request.SetPreviewsState(test.initial_request_previews_state);
 
     EXPECT_EQ(test.expected_should_use_client_lo_fi_for_request,
               frame()->ShouldUseClientLoFiForRequest(request))
         << (&test - tests);
   }
 }
 
 }  // namespace content