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"
+#include "ui/events/latency_info.h"
 
 namespace content {
 
 namespace {
 
 class TestRequestFactory;
 
 const int kChildId = 30;
 const int kRouteId = 75;
 const int kChildId2 = 43;
@@ skipping 101 matching lines @@
       : next_request_id_(0),
         ui_thread_(BrowserThread::UI, &message_loop_),
         io_thread_(BrowserThread::IO, &message_loop_),
         mock_timer_(new base::MockTimer(true, true)) {
     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, true);
+    scheduler_.OnClientCreated(kBackgroundChildId, kBackgroundRouteId, false);
     context_.set_http_server_properties(http_server_properties_.GetWeakPtr());
   }
 
   virtual ~ResourceSchedulerTest() {
     scheduler_.OnClientDeleted(kChildId, kRouteId);
     scheduler_.OnClientDeleted(kBackgroundChildId, kBackgroundRouteId);
   }
 
   scoped_ptr<net::URLRequest> NewURLRequestWithChildAndRoute(
       const char* url,
@@ skipping 470 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, false);
 
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId2,
                                                 kBackgroundRouteId2));
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 }
 
 TEST_F(ResourceSchedulerTest, ActiveClientThrottleUpdateOnLoadingChange) {
   // TODO(aiolos): remove when throttling and coalescing have both landed
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
@@ skipping 363 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, false);
+  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
   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,
@@ skipping 34 matching lines @@
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 }
 
 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, false);
+  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
   scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
   scheduler_.OnAudibilityChanged(kChildId, kRouteId, true);
 
   // 1 audible, 3 hidden
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
@@ skipping 35 matching lines @@
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 }
 
 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, false);
+  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
   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,
@@ skipping 33 matching lines @@
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 }
 
 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, false);
+  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
   scheduler_.OnLoadingStateChanged(kChildId2, kRouteId2, true);
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
   scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
   scheduler_.OnAudibilityChanged(kChildId, kRouteId, true);
   // 1 audible, 3 hidden
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
@@ skipping 34 matching lines @@
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 }
 
 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, true);
+  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
 
   // 2 visible, 2 hidden
-  scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, 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));
   EXPECT_EQ(ResourceScheduler::ACTIVE_AND_LOADING,
@@ skipping 42 matching lines @@
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 }
 
 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, false);
+  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
   scheduler_.OnAudibilityChanged(kChildId, kRouteId, true);
   scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
   scheduler_.OnAudibilityChanged(kChildId2, kRouteId2, true);
   // 2 audible, 2 hidden
   EXPECT_FALSE(scheduler_.active_clients_loaded());
   EXPECT_EQ(ResourceScheduler::THROTTLED,
             scheduler_.GetClientStateForTesting(kBackgroundChildId,
                                                 kBackgroundRouteId));
@@ skipping 48 matching lines @@
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 }
 
 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, true);
+  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
   scheduler_.OnLoadingStateChanged(kChildId2, kRouteId2, true);
-  scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, true);
   // 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));
@@ skipping 43 matching lines @@
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 }
 
 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, false);
+  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
   scheduler_.OnLoadingStateChanged(
       kBackgroundChildId2, kBackgroundRouteId2, true);
   scheduler_.OnLoadingStateChanged(kChildId2, kRouteId2, true);
   scheduler_.OnVisibilityChanged(kChildId, kRouteId, false);
   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,
@@ skipping 49 matching lines @@
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 }
 
 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, true);
+  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
 
   // 1 visible and 2 hidden loading, 1 visible loaded
-  scheduler_.OnVisibilityChanged(kChildId2, kRouteId2, 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::ACTIVE_AND_LOADING,
             scheduler_.GetClientStateForTesting(kChildId2, kRouteId2));
@@ skipping 46 matching lines @@
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 }
 
 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, true);
+  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
 
   // 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 32 matching lines @@
             scheduler_.GetClientStateForTesting(kChildId, kRouteId));
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 }
 
 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, true);
+  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
 
   // 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 44 matching lines @@
 
   scheduler_.OnClientDeleted(kChildId2, kRouteId2);
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 }
 
 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, true);
+  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
 
   // 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,
@@ skipping 115 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, false);
   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);
   EXPECT_TRUE(mock_timer_->IsRunning());
 
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
   EXPECT_FALSE(mock_timer_->IsRunning());
 
   // To avoid errors on test tear down.
-  scheduler_.OnClientCreated(kBackgroundChildId, kBackgroundRouteId);
+  scheduler_.OnClientCreated(kBackgroundChildId, kBackgroundRouteId, false);
 }
 
 TEST_F(ResourceSchedulerTest, LastCoalescedClientStartsLoadingStopsTimer) {
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                           true /* should_coalesce */);
-  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
+  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
   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);
@@ skipping 10 matching lines @@
       kBackgroundChildId2, kBackgroundRouteId2, false);
   EXPECT_FALSE(mock_timer_->IsRunning());
 
   // This is needed to avoid errors on test tear down.
   scheduler_.OnClientDeleted(kBackgroundChildId2, kBackgroundRouteId2);
 }
 
 TEST_F(ResourceSchedulerTest, LastCoalescedClientBecomesVisibleStopsTimer) {
   scheduler_.SetThrottleOptionsForTesting(true /* should_throttle */,
                                           true /* should_coalesce */);
-  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2);
+  scheduler_.OnClientCreated(kBackgroundChildId2, kBackgroundRouteId2, false);
   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);
@@ skipping 160 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, GetVisualSignalFromRenderViewHost) {
+  scoped_ptr<MockRenderProcessHostFactory> render_process_host_factory;
+  scoped_ptr<TestBrowserContext> browser_context;
+  scoped_ptr<TestWebContents> web_contents_1;
+  scoped_ptr<TestWebContents> web_contents_2;
+
+  render_process_host_factory.reset(new MockRenderProcessHostFactory());
+  browser_context.reset(new TestBrowserContext());
+  scoped_refptr<SiteInstance> site_instance_1 =
+      SiteInstance::Create(browser_context.get());
+  scoped_refptr<SiteInstance> site_instance_2 =
+      SiteInstance::Create(browser_context.get());
+  SiteInstanceImpl::set_render_process_host_factory(
+          render_process_host_factory.get());
+
+  web_contents_1.reset(
+      TestWebContents::Create(browser_context.get(), site_instance_1.get()));
+  web_contents_2.reset(
+      TestWebContents::Create(browser_context.get(), site_instance_2.get()));
+  base::RunLoop().RunUntilIdle();
+
+  RenderViewHostImpl* rvh1 = web_contents_1->GetRenderViewHost();
+  RenderViewHostImpl* rvh2 = web_contents_2->GetRenderViewHost();
+
+  rvh1->WasShown(ui::LatencyInfo());
+  rvh2->WasHidden();
+  base::RunLoop().RunUntilIdle();
+
+  ResourceScheduler* scheduler = ResourceDispatcherHostImpl::Get()->scheduler();
+
+  // Check initial visibility

[mmenke, 2014/08/20 20:21:43]

This isn't initial visibility, since you've already sent wasshown/hidden events.
 Ideally, we'd create rvh1 as visible and rvh2 as hidden, but I don't think we
can do that.  Instead, and we look at rvh1 and rvh2 just after creation, and
make sure that the scheduler starts out with the correct visibility values,
whatever they may be?

[Zhen Wang, 2014/08/21 03:34:48]

Done.

+  EXPECT_TRUE(scheduler->IsClientVisibleForTesting(rvh1->GetProcess()->GetID(),
+                                                   rvh1->GetRoutingID()));
+  EXPECT_FALSE(scheduler->IsClientVisibleForTesting(rvh2->GetProcess()->GetID(),
+                                                    rvh2->GetRoutingID()));
+
+  // Flip the visibility and check again

[mmenke, 2014/08/20 20:21:43]

nit:  End comments that are sentences (Or at least sentence-like) with periods
(x3).

[Zhen Wang, 2014/08/21 03:34:48]

Done.

+  rvh1->WasHidden();
+  rvh2->WasShown(ui::LatencyInfo());
+  base::RunLoop().RunUntilIdle();
+
+  EXPECT_FALSE(scheduler->IsClientVisibleForTesting(rvh1->GetProcess()->GetID(),
+                                                    rvh1->GetRoutingID()));
+  EXPECT_TRUE(scheduler->IsClientVisibleForTesting(rvh2->GetProcess()->GetID(),
+                                                   rvh2->GetRoutingID()));
+  // Clean up
+  web_contents_1.reset();
+  web_contents_2.reset();
+  base::RunLoop().RunUntilIdle();
+
+  browser_context.reset();
+  render_process_host_factory.reset();
+}
+
 }  // unnamed namespace
 
 }  // namespace content