Allow WebExternalTextureLayers to receive a bitmap along with a mailbox

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 <algorithm>
 #include <stack>
 
 #include "base/bind.h"
@@ skipping 105 matching lines @@
   return InitializeProxy(proxy_for_testing.Pass());
 }
 
 bool LayerTreeHost::InitializeProxy(scoped_ptr<Proxy> proxy) {
   TRACE_EVENT0("cc", "LayerTreeHost::InitializeForReal");
 
   scoped_ptr<OutputSurface> output_surface(CreateOutputSurface());
   if (!output_surface)
     return false;
 
+  using_gl_renderer_ =
+      output_surface->context3d() ||
+      output_surface->capabilities().deferred_gl_initialization;

[piman, 2013/07/02 04:00:09]

Note: during the lifetime of the LTH, we may recreate the OutputSurface after a
lost context - see e.g. ThreadProxy::DoCreateAndInitializeOutputSurface()

I think it will happen that a recreated output surface will have a different
type than the one created at the beginning, e.g. if we completely lost the GPU
context and we're blacklisted for the session, and we want to fallback to
software. Even if not now, that's something we want to be able to do eventually.

Based on that, maybe what's best to do is to keep this flag on the
RendererCapabilities, and it should flow naturally to the LTH before the first
commit on that new surface - maybe renamed as "using_shared_memory_resources" or
something.

[jbauman, 2013/07/02 20:16:19]

Ok, I'm now passing it through RendererCapabilities instead.

+
   proxy_ = proxy.Pass();
   proxy_->Start(output_surface.Pass());
   return true;
 }
 
 LayerTreeHost::~LayerTreeHost() {
   TRACE_EVENT0("cc", "LayerTreeHost::~LayerTreeHost");
   if (root_layer_.get())
     root_layer_->SetLayerTreeHost(NULL);
 
@@ skipping 539 matching lines @@
     return;
 
   lcd_text_metrics_.total_num_cc_layers++;
   if (layer->draw_properties().can_use_lcd_text) {
     lcd_text_metrics_.total_num_cc_layers_can_use_lcd_text++;
     if (layer->contents_opaque())
       lcd_text_metrics_.total_num_cc_layers_will_use_lcd_text++;
   }
 }
 
+bool LayerTreeHost::UsingGLRenderer() { return using_gl_renderer_; }
+
 void LayerTreeHost::UpdateLayers(Layer* root_layer,
                                  ResourceUpdateQueue* queue) {
   TRACE_EVENT1("cc", "LayerTreeHost::UpdateLayers",
                "commit_number", commit_number());
 
   LayerList update_list;
   {
     UpdateHudLayer();
 
     Layer* root_scroll = FindFirstScrollableLayer(root_layer);
@@ skipping 353 matching lines @@
     bool start_ready_animations = true;
     (*iter).second->UpdateState(start_ready_animations, NULL);
   }
 }
 
 skia::RefPtr<SkPicture> LayerTreeHost::CapturePicture() {
   return proxy_->CapturePicture();
 }
 
 }  // namespace cc