ResourceScheduler get visual signal from RenderViewHostImpl

content/browser/loader/resource_scheduler.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 <set>
 
 #include "content/browser/loader/resource_scheduler.h"
 
 #include "base/stl_util.h"
 #include "content/common/resource_messages.h"
 #include "content/browser/loader/resource_message_delegate.h"
 #include "content/public/browser/resource_controller.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/resource_throttle.h"
+#include "content/public/browser/web_contents_observer.h"
 #include "ipc/ipc_message_macros.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/load_flags.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_server_properties.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
 
 namespace content {
 
@@ skipping 196 matching lines @@
 }
 
 void ResourceScheduler::RequestQueue::Insert(
     ScheduledResourceRequest* request) {
   DCHECK(!ContainsKey(pointers_, request));
   request->set_fifo_ordering(MakeFifoOrderingId());
   pointers_[request] = queue_.insert(request);
 }
 
 // Each client represents a tab.
-class ResourceScheduler::Client {
+class ResourceScheduler::Client : public content::WebContentsObserver {
  public:
-  explicit Client(ResourceScheduler* scheduler)
-      : is_audible_(false),
+  explicit Client(ResourceScheduler* scheduler,
+                  int child_id,
+                  int route_id,
+                  WebContents* web_contents)
+      : child_id_(child_id),
+        route_id_(route_id),
+        is_audible_(false),
         is_visible_(false),
         is_loaded_(false),
         is_paused_(false),
         has_body_(false),
         using_spdy_proxy_(false),
         total_delayable_count_(0),
         throttle_state_(ResourceScheduler::THROTTLED) {
     scheduler_ = scheduler;
+    Observe(web_contents);

[aiolos (Not reviewing), 2014/08/13 21:40:33]

Do you need to set the initial visibility on Client creation, or will WasShown
always be called after Client creation? I thought it was the former, but it's
been a while since I looked. Have you tested the case of the initial foreground
tab to make sure it's marked as visible?

[Zhen Wang, 2014/08/14 22:19:52]

I set the visibility here now. Test added.

On 2014/08/13 21:40:33, aiolos wrote:

   }
 
-  ~Client() {
+  virtual ~Client() {
     // Update to default state and pause to ensure the scheduler has a
     // correct count of relevant types of clients.
     is_visible_ = false;
     is_audible_ = false;
     is_paused_ = true;
     UpdateThrottleState();
   }
 
+  // WebContentsObserver implementation.
+  virtual void WasShown() OVERRIDE {
+    scheduler_->OnVisibilityChanged(child_id_, route_id_, true);

[aiolos (Not reviewing), 2014/08/13 21:40:33]

This makes a longer loop than needed to set the information. Ie Client ->
ResourceScheduler -> Client. Just call the Client::OnVisibilityChanged directly
from here.

You can just remove ResourceScheduler::OnVisibilityChanged.

[Zhen Wang, 2014/08/14 22:19:52]

Done.

+  }
+
+  // WebContentsObserver implementation.
+  virtual void WasHidden() OVERRIDE {
+    scheduler_->OnVisibilityChanged(child_id_, route_id_, false);

[aiolos (Not reviewing), 2014/08/13 21:40:33]

Same as above.

[Zhen Wang, 2014/08/14 22:19:52]

Done.

+  }
+
   void ScheduleRequest(
       net::URLRequest* url_request,
       ScheduledResourceRequest* request) {
     if (ShouldStartRequest(request) == START_REQUEST) {
       StartRequest(request);
     } else {
       pending_requests_.Insert(request);
     }
   }
 
@@ skipping 17 matching lines @@
       (*it)->set_accounted_as_delayable_request(false);
     }
     ClearInFlightRequests();
     return unowned_requests;
   }
 
   bool is_active() const { return is_visible_ || is_audible_; }
 
   bool is_loaded() const { return is_loaded_; }
 
+  bool IsVisible() const { return is_visible_; }
+
   void OnAudibilityChanged(bool is_audible) {
     if (is_audible == is_audible_) {
       return;
     }
     is_audible_ = is_audible;
     UpdateThrottleState();
   }
 
   void OnVisibilityChanged(bool is_visible) {
     if (is_visible == is_visible_) {
@@ skipping 339 matching lines @@
       } else if (query_result == DO_NOT_START_REQUEST_AND_KEEP_SEARCHING) {
         ++request_iter;
         continue;
       } else {
         DCHECK(query_result == DO_NOT_START_REQUEST_AND_STOP_SEARCHING);
         break;
       }
     }
   }
 
+  const int child_id_;
+  const int route_id_;
   bool is_audible_;
   bool is_visible_;
   bool is_loaded_;
   bool is_paused_;
   bool has_body_;
   bool using_spdy_proxy_;
   RequestQueue pending_requests_;
   RequestSet in_flight_requests_;
   ResourceScheduler* scheduler_;
   // The number of delayable in-flight requests.
@@ skipping 64 matching lines @@
 
   ClientMap::iterator client_it = client_map_.find(request->client_id());
   if (client_it == client_map_.end()) {
     return;
   }
 
   Client* client = client_it->second;
   client->RemoveRequest(request);
 }
 
-void ResourceScheduler::OnClientCreated(int child_id, int route_id) {
+void ResourceScheduler::OnClientCreated(int child_id,
+                                        int route_id,
+                                        WebContents* web_contents) {
   DCHECK(CalledOnValidThread());
   ClientId client_id = MakeClientId(child_id, route_id);
   DCHECK(!ContainsKey(client_map_, client_id));
 
-  Client* client = new Client(this);
+  Client* client = new Client(this, child_id, route_id, web_contents);
   client_map_[client_id] = client;
 
   // TODO(aiolos): set Client visibility/audibility when signals are added
   // this will UNTHROTTLE Clients as needed
   client->UpdateThrottleState();
 }
 
 void ResourceScheduler::OnClientDeleted(int child_id, int route_id) {
   DCHECK(CalledOnValidThread());
   ClientId client_id = MakeClientId(child_id, route_id);
@@ skipping 76 matching lines @@
 }
 
 void ResourceScheduler::OnLoadingStateChanged(int child_id,
                                               int route_id,
                                               bool is_loaded) {
   Client* client = GetClient(child_id, route_id);
   DCHECK(client);
   client->OnLoadingStateChanged(is_loaded);
 }
 
+bool ResourceScheduler::ClientIsVisible(int child_id, int route_id) {

[aiolos (Not reviewing), 2014/08/13 21:40:33]

nit: IsClientVisible instead.

[Zhen Wang, 2014/08/14 22:19:52]

Done.

+  Client* client = GetClient(child_id, route_id);
+  DCHECK(client);
+  return client->IsVisible();
+}
+
 ResourceScheduler::Client* ResourceScheduler::GetClient(int child_id,
                                                         int route_id) {
   ClientId client_id = MakeClientId(child_id, route_id);
   ClientMap::iterator client_it = client_map_.find(client_id);
   if (client_it == client_map_.end()) {
     return NULL;
   }
   return client_it->second;
 }
 
@@ skipping 114 matching lines @@
   client->ReprioritizeRequest(
       request, old_priority_params, new_priority_params);
 }
 
 ResourceScheduler::ClientId ResourceScheduler::MakeClientId(
     int child_id, int route_id) {
   return (static_cast<ResourceScheduler::ClientId>(child_id) << 32) | route_id;
 }
 
 }  // namespace content