cc: Get rid of LayerTreeHost::output_surface_lost_ state.

cc/trees/layer_tree_host.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/layer_tree_host.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 195 matching lines @@
 LayerTreeHost::LayerTreeHost(InitParams* params,
                              CompositorMode mode,
                              std::unique_ptr<LayerTree> layer_tree)
     : micro_benchmark_controller_(this),
       layer_tree_(std::move(layer_tree)),
       next_ui_resource_id_(1),
       compositor_mode_(mode),
       client_(params->client),
       source_frame_number_(0),
       rendering_stats_instrumentation_(RenderingStatsInstrumentation::Create()),
-      output_surface_lost_(true),
       settings_(*params->settings),
       debug_state_(settings_.initial_debug_state),
       visible_(false),
       has_gpu_rasterization_trigger_(false),
       content_is_suitable_for_gpu_rasterization_(true),
       gpu_rasterization_histogram_recorded_(false),
       did_complete_scale_animation_(false),
       id_(s_layer_tree_host_sequence_number.GetNext() + 1),
       next_commit_forces_redraw_(false),
       shared_bitmap_manager_(params->shared_bitmap_manager),
@@ skipping 33 matching lines @@
 
 void LayerTreeHost::InitializeRemoteServer(
     RemoteProtoChannel* remote_proto_channel,
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner) {
   task_runner_provider_ = TaskRunnerProvider::Create(main_task_runner, nullptr);
 
   if (image_serialization_processor_) {
     engine_picture_cache_ =
         image_serialization_processor_->CreateEnginePictureCache();
   }
-
-  // The LayerTreeHost on the server never requests the output surface since
-  // it is only needed on the client. Since ProxyMain aborts commits if
-  // output_surface_lost() is true, always assume we have the output surface
-  // on the server.
-  output_surface_lost_ = false;
-
   InitializeProxy(ProxyMain::CreateRemote(remote_proto_channel, this,
                                           task_runner_provider_.get()),
                   nullptr);
 }
 
 void LayerTreeHost::InitializeRemoteClient(
     RemoteProtoChannel* remote_proto_channel,
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
   task_runner_provider_ =
@@ skipping 194 matching lines @@
   source_frame_number_++;
   client_->DidCommit();
   if (did_complete_scale_animation_) {
     client_->DidCompletePageScaleAnimation();
     did_complete_scale_animation_ = false;
   }
 }
 
 void LayerTreeHost::SetOutputSurface(std::unique_ptr<OutputSurface> surface) {
   TRACE_EVENT0("cc", "LayerTreeHost::SetOutputSurface");
-  DCHECK(output_surface_lost_);
   DCHECK(surface);
 
   DCHECK(!new_output_surface_);
   new_output_surface_ = std::move(surface);
   proxy_->SetOutputSurface(new_output_surface_.get());
 }
 
 std::unique_ptr<OutputSurface> LayerTreeHost::ReleaseOutputSurface() {
   DCHECK(!visible_);
-  DCHECK(!output_surface_lost_);
 
   DidLoseOutputSurface();
   proxy_->ReleaseOutputSurface();
   return std::move(current_output_surface_);
 }
 
 void LayerTreeHost::RequestNewOutputSurface() {
   client_->RequestNewOutputSurface();
 }
 
 void LayerTreeHost::DidInitializeOutputSurface() {
   DCHECK(new_output_surface_);
-  output_surface_lost_ = false;
   current_output_surface_ = std::move(new_output_surface_);
   client_->DidInitializeOutputSurface();
 }
 
 void LayerTreeHost::DidFailToInitializeOutputSurface() {
-  DCHECK(output_surface_lost_);
   DCHECK(new_output_surface_);
   // Note: It is safe to drop all output surface references here as
   // LayerTreeHostImpl will not keep a pointer to either the old or
   // new output surface after failing to initialize the new one.
   current_output_surface_ = nullptr;
   new_output_surface_ = nullptr;
   client_->DidFailToInitializeOutputSurface();
 }
 
 std::unique_ptr<LayerTreeHostImpl> LayerTreeHost::CreateLayerTreeHostImpl(
@@ skipping 17 matching lines @@
   shared_bitmap_manager_ = NULL;
   gpu_memory_buffer_manager_ = NULL;
   task_graph_runner_ = NULL;
   input_handler_weak_ptr_ = host_impl->AsWeakPtr();
   return host_impl;
 }
 
 void LayerTreeHost::DidLoseOutputSurface() {
   TRACE_EVENT0("cc", "LayerTreeHost::DidLoseOutputSurface");
   DCHECK(task_runner_provider_->IsMainThread());
-
-  if (output_surface_lost_)
-    return;
-
-  output_surface_lost_ = true;
   SetNeedsCommit();
 }
 
 void LayerTreeHost::SetDeferCommits(bool defer_commits) {
   proxy_->SetDeferCommits(defer_commits);
 }
 
 void LayerTreeHost::SetNeedsAnimate() {
   proxy_->SetNeedsAnimate();
   NotifySwapPromiseMonitorsOfSetNeedsCommit();
@@ skipping 88 matching lines @@
 }
 
 void LayerTreeHost::NotifyInputThrottledUntilCommit() {
   proxy_->NotifyInputThrottledUntilCommit();
 }
 
 void LayerTreeHost::LayoutAndUpdateLayers() {
   DCHECK(IsSingleThreaded());
   // This function is only valid when not using the scheduler.
   DCHECK(!settings_.single_thread_proxy_scheduler);
-  SingleThreadProxy* proxy = static_cast<SingleThreadProxy*>(proxy_.get());
-
-  if (output_surface_lost()) {
-    proxy->RequestNewOutputSurface();
-    // RequestNewOutputSurface could have synchronously created an output
-    // surface, so check again before returning.
-    if (output_surface_lost())
-      return;
-  }
-
   RequestMainFrameUpdate();
   UpdateLayers();
 }
 
 void LayerTreeHost::Composite(base::TimeTicks frame_begin_time) {
   DCHECK(IsSingleThreaded());
   // This function is only valid when not using the scheduler.
   DCHECK(!settings_.single_thread_proxy_scheduler);
   SingleThreadProxy* proxy = static_cast<SingleThreadProxy*>(proxy_.get());
 
   proxy->CompositeImmediately(frame_begin_time);
 }
 
 bool LayerTreeHost::UpdateLayers() {
-  DCHECK(!output_surface_lost_);
   if (!layer_tree_->root_layer())
     return false;
   DCHECK(!layer_tree_->root_layer()->parent());
   bool result = DoUpdateLayers(layer_tree_->root_layer());
   micro_benchmark_controller_.DidUpdateLayers();
   return result || next_commit_forces_redraw_;
 }
 
 void LayerTreeHost::DidCompletePageScaleAnimation() {
   did_complete_scale_animation_ = true;
@@ skipping 421 matching lines @@
 
   surface_client_id_ = proto.surface_client_id();
   next_surface_sequence_ = proto.next_surface_sequence();
 }
 
 AnimationHost* LayerTreeHost::animation_host() const {
   return layer_tree_->animation_host();
 }
 
 }  // namespace cc