cc: Get rid of LayerTreeHost::output_surface_lost_ state.

cc/trees/single_thread_proxy.cc

 // Copyright 2011 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/trees/single_thread_proxy.h"
 
 #include "base/auto_reset.h"
 #include "base/memory/ptr_util.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/trace_event/trace_event.h"
@@ skipping 32 matching lines @@
       next_frame_is_newly_committed_frame_(false),
 #if DCHECK_IS_ON()
       inside_impl_frame_(false),
 #endif
       inside_draw_(false),
       defer_commits_(false),
       animate_requested_(false),
       commit_requested_(false),
       inside_synchronous_composite_(false),
       output_surface_creation_requested_(false),
+      output_surface_lost_(true),
       weak_factory_(this) {
   TRACE_EVENT0("cc", "SingleThreadProxy::SingleThreadProxy");
   DCHECK(task_runner_provider_);
   DCHECK(task_runner_provider_->IsMainThread());
   DCHECK(layer_tree_host);
 }
 
 void SingleThreadProxy::Start(
     std::unique_ptr<BeginFrameSource> external_begin_frame_source) {
   DebugScopedSetImplThread impl(task_runner_provider_);
@@ skipping 61 matching lines @@
   DebugScopedSetImplThread impl(task_runner_provider_);
 
   layer_tree_host_impl_->SetVisible(visible);
 
   if (scheduler_on_impl_thread_)
     scheduler_on_impl_thread_->SetVisible(layer_tree_host_impl_->visible());
 }
 
 void SingleThreadProxy::RequestNewOutputSurface() {
   DCHECK(task_runner_provider_->IsMainThread());
-  DCHECK(layer_tree_host_->output_surface_lost());
   output_surface_creation_callback_.Cancel();
   if (output_surface_creation_requested_)
     return;
   output_surface_creation_requested_ = true;
   layer_tree_host_->RequestNewOutputSurface();
 }
 
 void SingleThreadProxy::ReleaseOutputSurface() {
-  // |layer_tree_host_| should already be aware of this.
-  DCHECK(layer_tree_host_->output_surface_lost());
-
+  output_surface_lost_ = true;
   if (scheduler_on_impl_thread_)
     scheduler_on_impl_thread_->DidLoseOutputSurface();
   return layer_tree_host_impl_->ReleaseOutputSurface();
 }
 
 void SingleThreadProxy::SetOutputSurface(OutputSurface* output_surface) {
   DCHECK(task_runner_provider_->IsMainThread());
-  DCHECK(layer_tree_host_->output_surface_lost());
   DCHECK(output_surface_creation_requested_);
 
   bool success;
   {
     DebugScopedSetMainThreadBlocked main_thread_blocked(task_runner_provider_);
     DebugScopedSetImplThread impl(task_runner_provider_);
     success = layer_tree_host_impl_->InitializeRenderer(output_surface);
   }
 
   if (success) {
     layer_tree_host_->DidInitializeOutputSurface();
     if (scheduler_on_impl_thread_)
       scheduler_on_impl_thread_->DidCreateAndInitializeOutputSurface();
     else if (!inside_synchronous_composite_)
       SetNeedsCommit();
     output_surface_creation_requested_ = false;
+    output_surface_lost_ = false;
   } else {
     // DidFailToInitializeOutputSurface is treated as a RequestNewOutputSurface,
     // and so output_surface_creation_requested remains true.
     layer_tree_host_->DidFailToInitializeOutputSurface();
   }
 }
 
 void SingleThreadProxy::SetNeedsAnimate() {
   TRACE_EVENT0("cc", "SingleThreadProxy::SetNeedsAnimate");
   DCHECK(task_runner_provider_->IsMainThread());
@@ skipping 274 matching lines @@
   TRACE_EVENT0("cc", "SingleThreadProxy::DidLoseOutputSurfaceOnImplThread");
   {
     DebugScopedSetMainThread main(task_runner_provider_);
     // This must happen before we notify the scheduler as it may try to recreate
     // the output surface if already in BEGIN_IMPL_FRAME_STATE_IDLE.
     layer_tree_host_->DidLoseOutputSurface();
   }
   client_->DidAbortSwapBuffers();
   if (scheduler_on_impl_thread_)
     scheduler_on_impl_thread_->DidLoseOutputSurface();
+  output_surface_lost_ = true;
 }
 
 void SingleThreadProxy::CommitVSyncParameters(base::TimeTicks timebase,
                                               base::TimeDelta interval) {
   if (synthetic_begin_frame_source_)
     synthetic_begin_frame_source_->OnUpdateVSyncParameters(timebase, interval);
 }
 
 void SingleThreadProxy::SetBeginFrameSource(BeginFrameSource* source) {
   DCHECK(layer_tree_host_->settings().single_thread_proxy_scheduler);
@@ skipping 24 matching lines @@
 }
 
 void SingleThreadProxy::CompositeImmediately(base::TimeTicks frame_begin_time) {
   TRACE_EVENT0("cc,benchmark", "SingleThreadProxy::CompositeImmediately");
   DCHECK(task_runner_provider_->IsMainThread());
 #if DCHECK_IS_ON()
   DCHECK(!inside_impl_frame_);
 #endif
   base::AutoReset<bool> inside_composite(&inside_synchronous_composite_, true);
 
-  if (layer_tree_host_->output_surface_lost()) {
+  if (output_surface_lost_) {
     RequestNewOutputSurface();
     // RequestNewOutputSurface could have synchronously created an output
     // surface, so check again before returning.
-    if (layer_tree_host_->output_surface_lost())
+    if (output_surface_lost_)
       return;
   }
 
   BeginFrameArgs begin_frame_args(BeginFrameArgs::Create(
       BEGINFRAME_FROM_HERE, frame_begin_time, base::TimeTicks(),
       BeginFrameArgs::DefaultInterval(), BeginFrameArgs::NORMAL));
 
   // Start the impl frame.
   {
     DebugScopedSetImplThread impl(task_runner_provider_);
@@ skipping 51 matching lines @@
     output_surface_creation_callback_.Reset(
         base::Bind(&SingleThreadProxy::RequestNewOutputSurface,
                    weak_factory_.GetWeakPtr()));
     task_runner_provider_->MainThreadTaskRunner()->PostTask(
         FROM_HERE, output_surface_creation_callback_.callback());
   }
 }
 
 DrawResult SingleThreadProxy::DoComposite(LayerTreeHostImpl::FrameData* frame) {
   TRACE_EVENT0("cc", "SingleThreadProxy::DoComposite");
-  DCHECK(!layer_tree_host_->output_surface_lost());
 
   DrawResult draw_result;
   bool draw_frame;
   {
     DebugScopedSetImplThread impl(task_runner_provider_);
     base::AutoReset<bool> mark_inside(&inside_draw_, true);
 
     // TODO(robliao): Remove ScopedTracker below once https://crbug.com/461509
     // is fixed.
     tracked_objects::ScopedTracker tracking_profile1(
@@ skipping 83 matching lines @@
 
 void SingleThreadProxy::DidCommitAndDrawFrame() {
   if (next_frame_is_newly_committed_frame_) {
     DebugScopedSetMainThread main(task_runner_provider_);
     next_frame_is_newly_committed_frame_ = false;
     layer_tree_host_->DidCommitAndDrawFrame();
   }
 }
 
 bool SingleThreadProxy::MainFrameWillHappenForTesting() {
-  if (layer_tree_host_->output_surface_lost())
-    return false;
   if (!scheduler_on_impl_thread_)
     return false;
   return scheduler_on_impl_thread_->MainFrameForTestingWillHappen();
 }
 
 void SingleThreadProxy::WillBeginImplFrame(const BeginFrameArgs& args) {
   DebugScopedSetImplThread impl(task_runner_provider_);
 #if DCHECK_IS_ON()
   DCHECK(!inside_impl_frame_)
       << "WillBeginImplFrame called while already inside an impl frame!";
@@ skipping 47 matching lines @@
   // commit.
   ScopedAbortRemainingSwapPromises swap_promise_checker(layer_tree_host_);
 
   if (!layer_tree_host_->visible()) {
     TRACE_EVENT_INSTANT0("cc", "EarlyOut_NotVisible", TRACE_EVENT_SCOPE_THREAD);
     BeginMainFrameAbortedOnImplThread(
         CommitEarlyOutReason::ABORTED_NOT_VISIBLE);
     return;
   }
 
-  if (layer_tree_host_->output_surface_lost()) {
-    TRACE_EVENT_INSTANT0("cc", "EarlyOut_OutputSurfaceLost",
-                         TRACE_EVENT_SCOPE_THREAD);
-    BeginMainFrameAbortedOnImplThread(
-        CommitEarlyOutReason::ABORTED_OUTPUT_SURFACE_LOST);
-    return;
-  }
-
   // Prevent new commits from being requested inside DoBeginMainFrame.
   // Note: We do not want to prevent SetNeedsAnimate from requesting
   // a commit here.
   commit_requested_ = true;
 
   DoBeginMainFrame(begin_frame_args);
 }
 
 void SingleThreadProxy::DoBeginMainFrame(
     const BeginFrameArgs& begin_frame_args) {
@@ skipping 88 matching lines @@
 void SingleThreadProxy::DidFinishImplFrame() {
   layer_tree_host_impl_->DidFinishImplFrame();
 #if DCHECK_IS_ON()
   DCHECK(inside_impl_frame_)
       << "DidFinishImplFrame called while not inside an impl frame!";
   inside_impl_frame_ = false;
 #endif
 }
 
 }  // namespace cc