Plumb SetVisible from ui::Compositor to the DirectRenderer.

cc/surfaces/display_scheduler.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/surfaces/display_scheduler.h"
 
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/stl_util.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/output/output_surface.h"
 
 namespace cc {
 
 DisplayScheduler::DisplayScheduler(BeginFrameSource* begin_frame_source,
                                    base::SingleThreadTaskRunner* task_runner,
                                    int max_pending_swaps)
     : begin_frame_source_(begin_frame_source),
       task_runner_(task_runner),
       inside_surface_damaged_(false),
+      visible_(false),
       output_surface_lost_(false),
       root_surface_resources_locked_(true),
       inside_begin_frame_deadline_interval_(false),
       needs_draw_(false),
       expecting_root_surface_damage_because_of_resize_(false),
       all_active_child_surfaces_ready_to_draw_(false),
       pending_swaps_(0),
       max_pending_swaps_(max_pending_swaps),
       observing_begin_frame_source_(false),
       root_surface_damaged_(false),
       expect_damage_from_root_surface_(false),
       weak_ptr_factory_(this) {
   begin_frame_deadline_closure_ = base::Bind(
       &DisplayScheduler::OnBeginFrameDeadline, weak_ptr_factory_.GetWeakPtr());
 }
 
 DisplayScheduler::~DisplayScheduler() {
-  if (observing_begin_frame_source_)
-    begin_frame_source_->RemoveObserver(this);
+  StopObservingBeginFrames();
 }
 
 void DisplayScheduler::SetClient(DisplaySchedulerClient* client) {
   client_ = client;
 }
 
+void DisplayScheduler::SetVisible(bool visible) {
+  if (visible_ == visible)
+    return;
+
+  visible_ = visible;
+  // If going invisible, we'll stop observing begin frames once we try
+  // to draw and fail.
+  StartObservingBeginFrames();
+  ScheduleBeginFrameDeadline();
+}
+
 // If we try to draw when the root surface resources are locked, the
 // draw will fail.
 void DisplayScheduler::SetRootSurfaceResourcesLocked(bool locked) {
   TRACE_EVENT1("cc", "DisplayScheduler::SetRootSurfaceResourcesLocked",
                "locked", locked);
   root_surface_resources_locked_ = locked;
   ScheduleBeginFrameDeadline();
 }
 
 // This is used to force an immediate swap before a resize.
@@ skipping 38 matching lines @@
     root_surface_damaged_ = true;
     expecting_root_surface_damage_because_of_resize_ = false;
   } else {
     child_surface_ids_damaged_.insert(surface_id);
 
     // TODO(mithro): Use hints from SetNeedsBeginFrames and SwapAborts.
     all_active_child_surfaces_ready_to_draw_ = base::STLIncludes(
         child_surface_ids_damaged_, child_surface_ids_to_expect_damage_from_);
   }
 
-  if (!output_surface_lost_ && !observing_begin_frame_source_) {
-    observing_begin_frame_source_ = true;
-    begin_frame_source_->AddObserver(this);
-  }
-
+  StartObservingBeginFrames();
   ScheduleBeginFrameDeadline();
 }
 
 void DisplayScheduler::OutputSurfaceLost() {
   TRACE_EVENT0("cc", "DisplayScheduler::OutputSurfaceLost");
   output_surface_lost_ = true;
   ScheduleBeginFrameDeadline();
 }
 
 void DisplayScheduler::DrawAndSwap() {
@@ skipping 56 matching lines @@
 
   // If we get another BeginFrame before a posted missed frame, just drop the
   // missed frame. Also if this was the missed frame, drop the Callback inside
   // it. Do this last because this might be the missed frame and we don't want
   // to destroy |args| prematurely.
   missed_begin_frame_task_.Cancel();
 
   return true;
 }
 
+void DisplayScheduler::StartObservingBeginFrames() {
+  if (!observing_begin_frame_source_ && needs_draw_ && !output_surface_lost_ &&
+      visible_) {
+    begin_frame_source_->AddObserver(this);
+    observing_begin_frame_source_ = true;
+  }
+}
+
+void DisplayScheduler::StopObservingBeginFrames() {
+  if (observing_begin_frame_source_) {
+    begin_frame_source_->RemoveObserver(this);
+    observing_begin_frame_source_ = false;
+
+    // A missed BeginFrame may be queued, so drop that too if we're going to
+    // stop listening.
+    missed_begin_frame_task_.Cancel();
+  }
+}
+
 void DisplayScheduler::OnBeginFrameSourcePausedChanged(bool paused) {
   // BeginFrameSources used with DisplayScheduler do not make use of this
   // feature.
   if (paused)
     NOTIMPLEMENTED();
 }
 
 base::TimeTicks DisplayScheduler::DesiredBeginFrameDeadlineTime() {
   if (output_surface_lost_) {
     TRACE_EVENT_INSTANT0("cc", "Lost output surface", TRACE_EVENT_SCOPE_THREAD);
@@ skipping 95 matching lines @@
                                 begin_frame_deadline_task_.callback(), delta);
   TRACE_EVENT2("cc", "Using new deadline", "delta", delta.ToInternalValue(),
                "desired_deadline", desired_deadline);
 }
 
 void DisplayScheduler::AttemptDrawAndSwap() {
   inside_begin_frame_deadline_interval_ = false;
   begin_frame_deadline_task_.Cancel();
   begin_frame_deadline_task_time_ = base::TimeTicks();
 
-  if (needs_draw_ && !output_surface_lost_) {
+  if (needs_draw_ && !output_surface_lost_ && visible_) {

[sunnyps, 2016/08/16 20:18:13]

nit: Can we extract needs_draw_ && !output_surface_lost_ && visible_ into a
separate method? (maybe ShouldDraw?)

[danakj, 2016/08/16 20:33:06]

Done.

     if (pending_swaps_ < max_pending_swaps_ && !root_surface_resources_locked_)
       DrawAndSwap();
   } else {
     // We are going idle, so reset expectations.
     child_surface_ids_to_expect_damage_from_.clear();
     child_surface_ids_damaged_prev_.clear();
     child_surface_ids_damaged_.clear();
     all_active_child_surfaces_ready_to_draw_ = true;
     expect_damage_from_root_surface_ = false;
 
-    if (observing_begin_frame_source_) {
-      observing_begin_frame_source_ = false;
-      begin_frame_source_->RemoveObserver(this);
-      // A missed BeginFrame may be queued, so drop that too if we're going to
-      // stop listening.
-      missed_begin_frame_task_.Cancel();
-    }
+    StopObservingBeginFrames();
   }
 }
 
 void DisplayScheduler::OnBeginFrameDeadline() {
   TRACE_EVENT0("cc", "DisplayScheduler::OnBeginFrameDeadline");
 
   AttemptDrawAndSwap();
   begin_frame_source_->DidFinishFrame(this, 0);
 }
 
 void DisplayScheduler::DidSwapBuffers() {
   pending_swaps_++;
   TRACE_EVENT_ASYNC_BEGIN1("cc", "DisplayScheduler:pending_swaps", this,
                            "pending_frames", pending_swaps_);
 }
 
 void DisplayScheduler::DidSwapBuffersComplete() {
   pending_swaps_--;
   TRACE_EVENT_ASYNC_END1("cc", "DisplayScheduler:pending_swaps", this,
                          "pending_frames", pending_swaps_);
   ScheduleBeginFrameDeadline();
 }
 
 }  // namespace cc