Remove cc::LayerTreeHostImpl::IsContextLost

cc/trees/layer_tree_host_impl.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_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 1084 matching lines @@
     }
   }
 }
 
 DrawResult LayerTreeHostImpl::PrepareToDraw(FrameData* frame) {
   TRACE_EVENT1("cc",
                "LayerTreeHostImpl::PrepareToDraw",
                "SourceFrameNumber",
                active_tree_->source_frame_number());
 
+  if (!have_valid_output_surface_)

[danakj, 2014/08/15 17:45:15]

For this to happen, we'd have to get the callback of a lost context in between
the Scheduler deciding to draw a frame and here. Is that possible? If it is, is
it worth having state/branches for when we could just draw to the lost context?

[dneto, 2014/08/15 17:58:20]

In a first attempt, I made LTHI::CanDraw return false when LTHI did not have a
valid output surface.  That caused mayhem in the layer-tree-host context-loss
unit tests, as it causes context loss in many of the points between starting
PrepareToDraw and DidDrawAllLayers, since many steps do DCHECK( CanDraw() ).

Is your suggestion similar?  I still am puzzled by when things can get
scheduled.

Or maybe I wasn't radical enough.  Could we always return true from
STP::DoComposite? And in that case we could also simplify
STP::CompositeImmediately a little.

[danakj, 2014/08/15 18:00:12]

Ya, make DoComposite return void. I'm suggesting that if the context is lost and
we're about to draw.. oh well draw anyways. The scheduler/embedder will hear
about it later and do something with it. Less branches keeps things simpler.

+    return DRAW_ABORTED_CONTEXT_LOST;
+
   if (need_to_update_visible_tiles_before_draw_ &&
       tile_manager_ && tile_manager_->UpdateVisibleTiles()) {
     DidInitializeVisibleTile();
   }
   need_to_update_visible_tiles_before_draw_ = true;
 
   UMA_HISTOGRAM_CUSTOM_COUNTS(
       "Compositing.NumActiveLayers", active_tree_->NumLayers(), 1, 400, 20);
 
   bool ok = active_tree_->UpdateDrawProperties();
@@ skipping 494 matching lines @@
   // Once all layers have been drawn, pending texture uploads should no
   // longer block future uploads.
   resource_provider_->MarkPendingUploadsAsNonBlocking();
 }
 
 void LayerTreeHostImpl::FinishAllRendering() {
   if (renderer_)
     renderer_->Finish();
 }
 
-bool LayerTreeHostImpl::IsContextLost() {
-  DCHECK(proxy_->IsImplThread());
-  // To avoid races, rely only on the lost-surface callback.
-  // See crbug.com/392891.
-  return !have_valid_output_surface_;
-}
-
 void LayerTreeHostImpl::SetUseGpuRasterization(bool use_gpu) {
   if (use_gpu == use_gpu_rasterization_)
     return;
 
   use_gpu_rasterization_ = use_gpu;
   ReleaseTreeResources();
 
   // Replace existing tile manager with another one that uses appropriate
   // rasterizer.
   if (tile_manager_) {
@@ skipping 1654 matching lines @@
   ResourceFormat format = resource_provider_->best_texture_format();
   switch (bitmap.GetFormat()) {
     case UIResourceBitmap::RGBA8:
       break;
     case UIResourceBitmap::ALPHA_8:
       format = ALPHA_8;
       break;
     case UIResourceBitmap::ETC1:
       format = ETC1;
       break;
-  };
+  }

[dneto, 2014/08/15 17:44:31]

This fixes a readability issue reported when I first tried to upload the patch.

   id = resource_provider_->CreateResource(
       bitmap.GetSize(),
       wrap_mode,
       ResourceProvider::TextureUsageAny,
       format);
 
   UIResourceData data;
   data.resource_id = id;
   data.size = bitmap.GetSize();
   data.opaque = bitmap.GetOpaque();
@@ skipping 95 matching lines @@
 }
 
 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
   std::vector<PictureLayerImpl*>::iterator it =
       std::find(picture_layers_.begin(), picture_layers_.end(), layer);
   DCHECK(it != picture_layers_.end());
   picture_layers_.erase(it);
 }
 
 }  // namespace cc