ResourceScheduler get visual signal from RenderViewHostImpl

content/browser/loader/resource_scheduler_unittest.cc

 // Copyright (c) 2012 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/loader/resource_scheduler.h"
 
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/timer/mock_timer.h"
 #include "base/timer/timer.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/loader/resource_message_filter.h"
 #include "content/browser/loader/resource_request_info_impl.h"
 #include "content/common/resource_messages.h"
 #include "content/public/browser/resource_context.h"
 #include "content/public/browser/resource_controller.h"
 #include "content/public/browser/resource_throttle.h"
 #include "content/public/common/process_type.h"
 #include "content/public/common/resource_type.h"
+#include "content/public/test/mock_render_process_host.h"
+#include "content/public/test/test_browser_context.h"
+#include "content/test/test_web_contents.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace content {
 
 namespace {
@@ skipping 101 matching lines @@
   FakeResourceContext context_;
 };
 
 class ResourceSchedulerTest : public testing::Test {
  protected:
   ResourceSchedulerTest()
       : next_request_id_(0),
         ui_thread_(BrowserThread::UI, &message_loop_),
         io_thread_(BrowserThread::IO, &message_loop_),
         mock_timer_(new base::MockTimer(true, true)) {
+    // Set up web contents.
+    render_process_host_factory_.reset(new MockRenderProcessHostFactory());
+    browser_context_.reset(new TestBrowserContext());
+    scoped_refptr<SiteInstance> site_instance =
+        SiteInstance::Create(browser_context_.get());
+    scoped_refptr<SiteInstance> site_instance_background =
+        SiteInstance::Create(browser_context_.get());
+    scoped_refptr<SiteInstance> site_instance_2 =
+        SiteInstance::Create(browser_context_.get());
+    scoped_refptr<SiteInstance> site_instance_background_2 =
+        SiteInstance::Create(browser_context_.get());
+    SiteInstanceImpl::set_render_process_host_factory(
+            render_process_host_factory_.get());
+
+    web_contents_.reset(
+        TestWebContents::Create(browser_context_.get(), site_instance.get()));
+    web_contents_background_.reset(
+        TestWebContents::Create(browser_context_.get(),
+                                site_instance_background.get()));
+    web_contents_2_.reset(
+        TestWebContents::Create(browser_context_.get(), site_instance_2.get()));
+    web_contents_background_2_.reset(
+        TestWebContents::Create(browser_context_.get(),
+                                site_instance_background_2.get()));
+    base::RunLoop().RunUntilIdle();
+
+    visual_observer_ = scheduler_.CreateVisualObserver(web_contents_.get());
+    visual_observer_background_ =
+        scheduler_.CreateVisualObserver(web_contents_background_.get());
+    visual_observer_2_ = scheduler_.CreateVisualObserver(web_contents_2_.get());
+    visual_observer_background_2_ =
+        scheduler_.CreateVisualObserver(web_contents_background_2_.get());
+
+    // set up resource scheduler
     scheduler_.set_timer_for_testing(scoped_ptr<base::Timer>(mock_timer_));
 
     // TODO(aiolos): Remove when throttling and coalescing have both landed.
     scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                             false /* should_coalesce */);
 
-    scheduler_.OnClientCreated(kChildId, kRouteId);
-    scheduler_.OnVisibilityChanged(kChildId, kRouteId, true);
-    scheduler_.OnClientCreated(kBackgroundChildId, kBackgroundRouteId);
+    scheduler_.OnClientCreated(kChildId, kRouteId, visual_observer_, false);
+    scheduler_.OnClientCreated(kBackgroundChildId,
+                               kBackgroundRouteId,
+                               visual_observer_background_,
+                               false);
+    base::RunLoop().RunUntilIdle();
+
     context_.set_http_server_properties(http_server_properties_.GetWeakPtr());
+
+    // Set up initial visibility.
+    web_contents_->WasShown();
+    web_contents_background_->WasHidden();
+    web_contents_2_->WasHidden();
+    web_contents_background_2_->WasHidden();
+    base::RunLoop().RunUntilIdle();
   }
 
   virtual ~ResourceSchedulerTest() {
     scheduler_.OnClientDeleted(kChildId, kRouteId);
     scheduler_.OnClientDeleted(kBackgroundChildId, kBackgroundRouteId);
+    base::RunLoop().RunUntilIdle();
+
+    web_contents_.reset();
+    web_contents_background_.reset();
+    web_contents_2_.reset();
+    web_contents_background_2_.reset();
+    base::RunLoop().RunUntilIdle();
+
+    browser_context_.reset();
+    render_process_host_factory_.reset();
   }
 
   scoped_ptr<net::URLRequest> NewURLRequestWithChildAndRoute(
       const char* url,
       net::RequestPriority priority,
       int child_id,
       int route_id,
       bool is_async) {
     scoped_ptr<net::URLRequest> url_request(
         context_.CreateRequest(GURL(url), priority, NULL, NULL));
@@ skipping 105 matching lines @@
 
   int next_request_id_;
   base::MessageLoopForIO message_loop_;
   BrowserThreadImpl ui_thread_;
   BrowserThreadImpl io_thread_;
   ResourceDispatcherHostImpl rdh_;
   ResourceScheduler scheduler_;
   base::MockTimer* mock_timer_;
   net::HttpServerPropertiesImpl http_server_properties_;
   net::TestURLRequestContext context_;
+  scoped_ptr<MockRenderProcessHostFactory> render_process_host_factory_;
+  scoped_ptr<TestBrowserContext> browser_context_;
+  scoped_ptr<TestWebContents> web_contents_;
+  scoped_ptr<TestWebContents> web_contents_background_;
+  scoped_ptr<TestWebContents> web_contents_2_;
+  scoped_ptr<TestWebContents> web_contents_background_2_;
+  ResourceScheduler::VisualObserver* visual_observer_;
+  ResourceScheduler::VisualObserver* visual_observer_background_;
+  ResourceScheduler::VisualObserver* visual_observer_2_;
+  ResourceScheduler::VisualObserver* visual_observer_background_2_;
 };
 
 TEST_F(ResourceSchedulerTest, OneIsolatedLowRequest) {
   scoped_ptr<TestRequest> request(NewRequest("http://host/1", net::LOWEST));
   EXPECT_TRUE(request->started());
 }
 
 TEST_F(ResourceSchedulerTest, OneLowLoadsUntilIdle) {
   scoped_ptr<TestRequest> high(NewRequest("http://host/high", net::HIGHEST));
   scoped_ptr<TestRequest> low(NewRequest("http://host/low", net::LOWEST));
@@ skipping 339 matching lines @@
   ChangeRequestPriority(low2_spdy.get(), net::LOWEST);
   scoped_ptr<TestRequest> low2(NewRequest("http://host/low", net::LOWEST));
   EXPECT_TRUE(low2->started());
 }
 
 TEST_F(ResourceSchedulerTest, ThrottledClientCreation) {
   // TODO(aiolos): remove when throttling and coalescing have both landed
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                           false /* should_coalesce */);
   EXPECT_TRUE(scheduler_.should_throttle());
-  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
+  scheduler_.OnClientCreated(kBackgroundChildId2,
+                             kBackgroundRouteId2,
+                             visual_observer_background_2_,
+                             false);
+  base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(ResourceSchedulerTest, ActiveClientThrottleUpdateOnLoadingChange) {
   // TODO(aiolos): remove when throttling and coalescing have both landed
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                           false /* should_coalesce */);
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
@@ skipping 61 matching lines @@
                                           false /* should_coalesce */);
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   scoped_ptr<TestRequest> high(
       NewBackgroundRequest("http://host/high", net::HIGHEST));
   scoped_ptr<TestRequest> request(
       NewBackgroundRequest("http://host/req", net::IDLE));
   EXPECT_FALSE(request->started());
 
-  scheduler_.OnVisibilityChanged(kBackgroundChildId, kBackgroundRouteId, true);
+  web_contents_background_->WasShown();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_TRUE(request->started());
 }
 
 TEST_F(ResourceSchedulerTest, UnthrottleNewlyAudibleClient) {
   // TODO(aiolos): remove when throttling and coalescing have both landed
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                           false /* should_coalesce */);
@@ skipping 35 matching lines @@
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
 }
 
 TEST_F(ResourceSchedulerTest, AudibleClientStillUnthrottledOnVisabilityChange) {
   // TODO(aiolos): remove when throttling and coalescing have both landed
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                           false /* should_coalesce */);
-  scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
+  web_contents_->WasHidden();
+  base::RunLoop().RunUntilIdle();
   scheduler_.OnAudibilityChanged(kChildId, kRouteId, true);
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
 
-  scheduler_.OnVisibilityChanged(kChildId, kRouteId, true);
+  web_contents_->WasShown();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
 
-  scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
+  web_contents_->WasHidden();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
 }
 
 TEST_F(ResourceSchedulerTest, ThrottledClientStartsNextHighestPriorityRequest) {
   // TODO(aiolos): remove when throttling and coalescing have both landed
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
@@ skipping 168 matching lines @@
   // TODO(aiolos): remove when throttling and coalescing have both landed
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                           false /* should_coalesce */);
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
   EXPECT_FALSE(scheduler_.active_clients_loaded());
 
-  scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
+  web_contents_->WasHidden();
+  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
 
   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
@@ skipping 16 matching lines @@
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
 }
 
 TEST_F(ResourceSchedulerTest,
        UnloadedClientVisibilityChangedCorrectlyUnthrottles) {
   // TODO(aiolos): remove when throttling and coalescing have both landed
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                           false /* should_coalesce */);
-  scheduler_.OnClientCreated(kChildId2, kRouteId2);
-  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
+  scheduler_.OnClientCreated(kChildId2, kRouteId2, visual_observer_2_, false);
+  scheduler_.OnClientCreated(kBackgroundChildId2,
+                             kBackgroundRouteId2,
+                             visual_observer_background_2_,
+                             false);
+  base::RunLoop().RunUntilIdle();
+
   scheduler_.OnLoadingStateChanged(kChildId2, kRouteId2, true);
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
 
   // 1 visible, 3 hidden
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   // 2 visible, 2 hidden
-  scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, true);
+  web_contents_2_->WasShown();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   // 1 visible, 3 hidden
-  scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, false);
+  web_contents_2_->WasHidden();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(ResourceSchedulerTest,
        UnloadedClientAudibilityChangedCorrectlyUnthrottles) {
   // TODO(aiolos): remove when throttling and coalescing have both landed
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                           false /* should_coalesce */);
-  scheduler_.OnClientCreated(kChildId2, kRouteId2);
-  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
+  scheduler_.OnClientCreated(kChildId2, kRouteId2, visual_observer_2_, false);
+  scheduler_.OnClientCreated(kBackgroundChildId2,
+                             kBackgroundRouteId2,
+                             visual_observer_background_2_,
+                             false);
+  base::RunLoop().RunUntilIdle();
+
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
-  scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
+  web_contents_->WasHidden();
+  base::RunLoop().RunUntilIdle();
   scheduler_.OnAudibilityChanged(kChildId, kRouteId, true);
 
   // 1 audible, 3 hidden
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
@@ skipping 25 matching lines @@
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(ResourceSchedulerTest,
        LoadedClientVisibilityChangedCorrectlyUnthrottles) {
   // TODO(aiolos): remove when throttling and coalescing have both landed
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                           false /* should_coalesce */);
-  scheduler_.OnClientCreated(kChildId2, kRouteId2);
-  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
+  scheduler_.OnClientCreated(kChildId2, kRouteId2, visual_observer_2_, false);
+  scheduler_.OnClientCreated(kBackgroundChildId2,
+                             kBackgroundRouteId2,
+                             visual_observer_background_2_,
+                             false);
+  base::RunLoop().RunUntilIdle();
+
   scheduler_.OnLoadingStateChanged(kChildId2, kRouteId2, true);
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
+
   // 1 visible, 3 hidden
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   // 2 visible, 2 hidden
-  scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, true);
+  web_contents_2_->WasShown();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   // 1 visible, 3 hidden
-  scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, false);
+  web_contents_2_->WasHidden();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(ResourceSchedulerTest,
        LoadedClientAudibilityChangedCorrectlyUnthrottles) {
   // TODO(aiolos): remove when throttling and coalescing have both landed
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                           false /* should_coalesce */);
-  scheduler_.OnClientCreated(kChildId2, kRouteId2);
-  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
+  scheduler_.OnClientCreated(kChildId2, kRouteId2, visual_observer_2_, false);
+  scheduler_.OnClientCreated(kBackgroundChildId2,
+                             kBackgroundRouteId2,
+                             visual_observer_background_2_,
+                             false);
+  base::RunLoop().RunUntilIdle();
+
   scheduler_.OnLoadingStateChanged(kChildId2, kRouteId2, true);
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
-  scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
+  web_contents_->WasHidden();
+  base::RunLoop().RunUntilIdle();
   scheduler_.OnAudibilityChanged(kChildId, kRouteId, true);
+
   // 1 audible, 3 hidden
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
@@ skipping 23 matching lines @@
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(ResourceSchedulerTest, UnloadedClientBecomesHiddenCorrectlyUnthrottles) {
   // TODO(aiolos): remove when throttling and coalescing have both landed
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                           false /* should_coalesce */);
-  scheduler_.OnClientCreated(kChildId2, kRouteId2);
-  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
+  scheduler_.OnClientCreated(kChildId2, kRouteId2, visual_observer_2_, false);
+  scheduler_.OnClientCreated(kBackgroundChildId2,
+                             kBackgroundRouteId2,
+                             visual_observer_background_2_,
+                             false);
+  base::RunLoop().RunUntilIdle();
+
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
 
   // 2 visible, 2 hidden
-  scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, true);
+  web_contents_2_->WasShown();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   // 1 visible, 3 hidden
-  scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, false);
+  web_contents_2_->WasHidden();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   // 0 visible, 4 hidden
-  scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
+  web_contents_->WasHidden();
+  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   // 1 visible, 3 hidden
-  scheduler_.OnVisibilityChanged(kChildId, kRouteId, true);
+  web_contents_->WasShown();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(ResourceSchedulerTest, UnloadedClientBecomesSilentCorrectlyUnthrottles) {
   // TODO(aiolos): remove when throttling and coalescing have both landed
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                           false /* should_coalesce */);
-  scheduler_.OnClientCreated(kChildId2, kRouteId2);
-  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
+  scheduler_.OnClientCreated(kChildId2, kRouteId2, visual_observer_2_, false);
+  scheduler_.OnClientCreated(kBackgroundChildId2,
+                             kBackgroundRouteId2,
+                             visual_observer_background_2_,
+                             false);
+  base::RunLoop().RunUntilIdle();
+
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
   scheduler_.OnAudibilityChanged(kChildId, kRouteId, true);
-  scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
+  web_contents_->WasHidden();
+  base::RunLoop().RunUntilIdle();
   scheduler_.OnAudibilityChanged(kChildId2, kRouteId2, true);
   // 2 audible, 2 hidden
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
@@ skipping 38 matching lines @@
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(ResourceSchedulerTest, LoadedClientBecomesHiddenCorrectlyThrottles) {
   // TODO(aiolos): remove when throttling and coalescing have both landed
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                           false /* should_coalesce */);
-  scheduler_.OnClientCreated(kChildId2, kRouteId2);
-  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
+  scheduler_.OnClientCreated(kChildId2, kRouteId2, visual_observer_2_, false);
+  scheduler_.OnClientCreated(kBackgroundChildId2,
+                             kBackgroundRouteId2,
+                             visual_observer_background_2_,
+                             false);
+  base::RunLoop().RunUntilIdle();
+
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
   scheduler_.OnLoadingStateChanged(kChildId2, kRouteId2, true);
-  scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, true);
+  web_contents_2_->WasShown();
+  base::RunLoop().RunUntilIdle();
+
   // 2 visible, 2 hidden
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   // 1 visible, 3 hidden
-  scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, false);
+  web_contents_2_->WasHidden();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   // 0 visible, 4 hidden
-  scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
+  web_contents_->WasHidden();
+  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   // 1 visible, 3 hidden
-  scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, true);
+  web_contents_2_->WasShown();
+  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(ResourceSchedulerTest, LoadedClientBecomesSilentCorrectlyThrottles) {
   // TODO(aiolos): remove when throttling and coalescing have both landed
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                           false /* should_coalesce */);
-  scheduler_.OnClientCreated(kChildId2, kRouteId2);
-  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
+  scheduler_.OnClientCreated(kChildId2, kRouteId2, visual_observer_2_, false);
+  scheduler_.OnClientCreated(kBackgroundChildId2,
+                             kBackgroundRouteId2,
+                             visual_observer_background_2_,
+                             false);
+  base::RunLoop().RunUntilIdle();
+
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
   scheduler_.OnLoadingStateChanged(kChildId2, kRouteId2, true);
-  scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
+  web_contents_->WasHidden();
+  base::RunLoop().RunUntilIdle();
   scheduler_.OnAudibilityChanged(kChildId, kRouteId, true);
   scheduler_.OnAudibilityChanged(kChildId2, kRouteId2, true);
+
   // 2 audible, 2 hidden
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
@@ skipping 37 matching lines @@
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(ResourceSchedulerTest, HiddenLoadedChangesCorrectlyStayThrottled) {
   // TODO(aiolos): remove when throttling and coalescing have both landed
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                           false /* should_coalesce */);
-  scheduler_.OnClientCreated(kChildId2, kRouteId2);
-  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
+  scheduler_.OnClientCreated(kChildId2, kRouteId2, visual_observer_2_, false);
+  scheduler_.OnClientCreated(kBackgroundChildId2,
+                             kBackgroundRouteId2,
+                             visual_observer_background_2_,
+                             false);
+  base::RunLoop().RunUntilIdle();
 
   // 1 visible and 2 hidden loading, 1 visible loaded
-  scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, true);
+  web_contents_2_->WasShown();
+  base::RunLoop().RunUntilIdle();
   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
@@ skipping 40 matching lines @@
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(ResourceSchedulerTest, PartialVisibleClientLoadedDoesNotUnthrottle) {
   // TODO(aiolos): remove when throttling and coalescing have both landed
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                           false /* should_coalesce */);
-  scheduler_.OnClientCreated(kChildId2, kRouteId2);
-  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
-  scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, true);
+  scheduler_.OnClientCreated(kChildId2, kRouteId2, visual_observer_2_, false);
+  scheduler_.OnClientCreated(kBackgroundChildId2,
+                             kBackgroundRouteId2,
+                             visual_observer_background_2_,
+                             false);
+  base::RunLoop().RunUntilIdle();
+
+  web_contents_2_->WasShown();
+  base::RunLoop().RunUntilIdle();
 
   // 2 visible loading, 1 hidden loading, 1 hidden loaded
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
@@ skipping 26 matching lines @@
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(ResourceSchedulerTest, FullVisibleLoadedCorrectlyUnthrottle) {
   // TODO(aiolos): remove when throttling and coalescing have both landed
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                           false /* should_coalesce */);
-  scheduler_.OnClientCreated(kChildId2, kRouteId2);
-  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
-  scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, true);
+  scheduler_.OnClientCreated(kChildId2, kRouteId2, visual_observer_2_, false);
+  scheduler_.OnClientCreated(kBackgroundChildId2,
+                             kBackgroundRouteId2,
+                             visual_observer_background_2_,
+                             false);
+  base::RunLoop().RunUntilIdle();
+
+  web_contents_2_->WasShown();
+  base::RunLoop().RunUntilIdle();
 
   // 1 visible and 1 hidden loaded, 1 visible and 1 hidden loading
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
   scheduler_.OnLoadingStateChanged(kChildId2, kRouteId2, true);
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
@@ skipping 37 matching lines @@
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(ResourceSchedulerTest,
        ActiveAndLoadingClientDeletedCorrectlyUnthrottle) {
   // TODO(aiolos): remove when throttling and coalescing have both landed
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                           false /* should_coalesce */);
-  scheduler_.OnClientCreated(kChildId2, kRouteId2);
-  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
-  scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, true);
+  scheduler_.OnClientCreated(kChildId2, kRouteId2, visual_observer_2_, false);
+  scheduler_.OnClientCreated(kBackgroundChildId2,
+                             kBackgroundRouteId2,
+                             visual_observer_background_2_,
+                             false);
+  base::RunLoop().RunUntilIdle();
+
+  web_contents_2_->WasShown();
+  base::RunLoop().RunUntilIdle();
 
   // 1 visible and 1 hidden loaded, 1 visible and 1 hidden loading
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
 
   // 1 visible loaded, 1 hidden loading, 1 hidden loaded
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
+  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   // 1 visible and 1 hidden loaded, 1 visible and 1 hidden loading
   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, false);
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(ResourceSchedulerTest, CoalescedClientCreationStartsTimer) {
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                           true /* should_coalesce */);
   EXPECT_FALSE(mock_timer_->IsRunning());
   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
   EXPECT_FALSE(mock_timer_->IsRunning());
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId, kBackgroundRouteId, true);
@@ skipping 15 matching lines @@
   EXPECT_FALSE(mock_timer_->IsRunning());
 
   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_FALSE(mock_timer_->IsRunning());
 
-  scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
+  web_contents_->WasHidden();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(ResourceScheduler::COALESCED,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_TRUE(mock_timer_->IsRunning());
 }
 
 TEST_F(ResourceSchedulerTest, ActiveLoadingClientHiddenAndLoadedStartsTimer) {
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                           true /* should_coalesce */);
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_FALSE(mock_timer_->IsRunning());
 
-  scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
+  web_contents_->WasHidden();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
   EXPECT_FALSE(mock_timer_->IsRunning());
 
   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_EQ(ResourceScheduler::COALESCED,
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
@@ skipping 18 matching lines @@
   scheduler_.OnAudibilityChanged(kBackgroundChildId, kBackgroundRouteId, true);
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_FALSE(mock_timer_->IsRunning());
 }
 
 TEST_F(ResourceSchedulerTest, LastCoalescedClientDeletionStopsTimer) {
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                           true /* should_coalesce */);
-  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
+  scheduler_.OnClientCreated(kBackgroundChildId2,
+                             kBackgroundRouteId2,
+                             visual_observer_background_2_,
+                             false);
+  base::RunLoop().RunUntilIdle();
+
   EXPECT_FALSE(mock_timer_->IsRunning());
   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
   EXPECT_FALSE(mock_timer_->IsRunning());
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId, kBackgroundRouteId, true);
   EXPECT_EQ(ResourceScheduler::COALESCED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
   EXPECT_EQ(ResourceScheduler::COALESCED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_TRUE(mock_timer_->IsRunning());
 
   scheduler_.OnClientDeleted(kBackgroundChildId, kBackgroundRouteId);
+  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(mock_timer_->IsRunning());
 
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(mock_timer_->IsRunning());
 
   // To avoid errors on test tear down.
-  scheduler_.OnClientCreated(kBackgroundChildId, kBackgroundRouteId);
+  scheduler_.OnClientCreated(kBackgroundChildId,
+                             kBackgroundRouteId,
+                             NULL,
+                             false);
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(ResourceSchedulerTest, LastCoalescedClientStartsLoadingStopsTimer) {
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                           true /* should_coalesce */);
-  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
+  scheduler_.OnClientCreated(kBackgroundChildId2,
+                             kBackgroundRouteId2,
+                             visual_observer_background_2_,
+                             false);
+  base::RunLoop().RunUntilIdle();
+
   EXPECT_FALSE(mock_timer_->IsRunning());
   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
   EXPECT_FALSE(mock_timer_->IsRunning());
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId, kBackgroundRouteId, true);
   EXPECT_EQ(ResourceScheduler::COALESCED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
   EXPECT_EQ(ResourceScheduler::COALESCED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_TRUE(mock_timer_->IsRunning());
 
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId, kBackgroundRouteId, false);
   EXPECT_TRUE(mock_timer_->IsRunning());
 
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, false);
   EXPECT_FALSE(mock_timer_->IsRunning());
 
   // This is needed to avoid errors on test tear down.
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(ResourceSchedulerTest, LastCoalescedClientBecomesVisibleStopsTimer) {
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                           true /* should_coalesce */);
-  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
+  scheduler_.OnClientCreated(kBackgroundChildId2,
+                             kBackgroundRouteId2,
+                             visual_observer_background_2_,
+                             false);
+  base::RunLoop().RunUntilIdle();
+
   EXPECT_FALSE(mock_timer_->IsRunning());
   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
   EXPECT_FALSE(mock_timer_->IsRunning());
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId, kBackgroundRouteId, true);
   EXPECT_EQ(ResourceScheduler::COALESCED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
   EXPECT_EQ(ResourceScheduler::COALESCED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   EXPECT_TRUE(mock_timer_->IsRunning());
 
-  scheduler_.OnVisibilityChanged(kBackgroundChildId, kBackgroundRouteId, true);
+  web_contents_background_->WasShown();
+  base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(mock_timer_->IsRunning());
 
-  scheduler_.OnVisibilityChanged(
-      kBackgroundChildId2, kBackgroundRouteId2, true);
+  web_contents_background_2_->WasShown();
+  base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(mock_timer_->IsRunning());
 
   // To avoid errors on test tear down.
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
+  base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(ResourceSchedulerTest,
        CoalescedClientBecomesLoadingAndVisibleStopsTimer) {
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                           true /* should_coalesce */);
   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
   EXPECT_FALSE(mock_timer_->IsRunning());
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId, kBackgroundRouteId, true);
   EXPECT_EQ(ResourceScheduler::COALESCED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_TRUE(mock_timer_->IsRunning());
 
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId, kBackgroundRouteId, false);
   EXPECT_EQ(ResourceScheduler::UNTHROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_FALSE(mock_timer_->IsRunning());
 
-  scheduler_.OnVisibilityChanged(kBackgroundChildId, kBackgroundRouteId, true);
+  web_contents_background_->WasShown();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
   EXPECT_FALSE(mock_timer_->IsRunning());
 }
 
 TEST_F(ResourceSchedulerTest, CoalescedRequestsIssueOnTimer) {
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                           true /* should_coalesce */);
   scheduler_.OnLoadingStateChanged(kChildId, kRouteId, true);
@@ skipping 113 matching lines @@
   EXPECT_FALSE(high2->started());
   EXPECT_FALSE(low->started());
 
   FireCoalescingTimer();
 
   EXPECT_TRUE(high->started());
   EXPECT_TRUE(high2->started());
   EXPECT_TRUE(low->started());
 }
 
+TEST_F(ResourceSchedulerTest, CheckInitialVisibility) {
+  scheduler_.OnClientCreated(kChildId2, kRouteId2, visual_observer_2_, false);
+  scheduler_.OnClientCreated(kBackgroundChildId2,
+                             kBackgroundRouteId2,
+                             visual_observer_background_2_,
+                             false);
+  base::RunLoop().RunUntilIdle();
+
+  web_contents_2_->WasShown();
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_TRUE(scheduler_.IsClientVisibleForTesting(kChildId2, kRouteId2));
+  EXPECT_FALSE(scheduler_.IsClientVisibleForTesting(kBackgroundChildId2,
+                                          kBackgroundRouteId2));
+
+  scheduler_.OnClientDeleted(kChildId2, kRouteId2);
+  scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
+  base::RunLoop().RunUntilIdle();
+}
+
+TEST_F(ResourceSchedulerTest, GetVisualSignalFromWebContents) {
+  scheduler_.OnClientCreated(kChildId2, kRouteId2, visual_observer_2_, false);
+  scheduler_.OnClientCreated(kBackgroundChildId2,
+                             kBackgroundRouteId2,
+                             visual_observer_background_2_,
+                             false);
+  base::RunLoop().RunUntilIdle();
+
+  web_contents_2_->WasShown();
+  base::RunLoop().RunUntilIdle();
+
+  // Change visibility of web contents.
+  web_contents_2_->WasHidden();
+  web_contents_background_2_->WasShown();
+  base::RunLoop().RunUntilIdle();
+
+  // The clients get the visual signal from web contents.
+  EXPECT_FALSE(scheduler_.IsClientVisibleForTesting(kChildId2, kRouteId2));
+  EXPECT_TRUE(scheduler_.IsClientVisibleForTesting(kBackgroundChildId2,
+                                          kBackgroundRouteId2));
+
+  scheduler_.OnClientDeleted(kChildId2, kRouteId2);
+  scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
+  base::RunLoop().RunUntilIdle();
+}
+
 }  // unnamed namespace
 
 }  // namespace content