Aura: Have ui::Layer implement WebKit::WebExternalTextureLayerClient

ui/compositor/layer.cc

 // Copyright (c) 2012 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 "ui/compositor/layer.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 293 matching lines @@
 void Layer::SetExternalTexture(Texture* texture) {
   DCHECK_EQ(type_, LAYER_TEXTURED);
   layer_updated_externally_ = !!texture;
   texture_ = texture;
   if (web_layer_is_accelerated_ != layer_updated_externally_) {
     // Switch to a different type of layer.
     web_layer_.removeAllChildren();
     WebKit::WebLayer new_layer;
     if (layer_updated_externally_) {
       WebKit::WebExternalTextureLayer texture_layer =
-          WebKit::WebExternalTextureLayer::create();
+          WebKit::WebExternalTextureLayer::create(this);
       texture_layer.setFlipped(texture_->flipped());
       new_layer = texture_layer;
     } else {
+      // Tell the compositor to clear references to the old texture.
+      WebKit::WebExternalTextureLayer texture_layer =
+          web_layer_.to<WebKit::WebExternalTextureLayer>();
+      texture_layer.willModifyTexture();
       new_layer = WebKit::WebContentLayer::create(this);
     }
     if (parent_) {
       DCHECK(!parent_->web_layer_.isNull());
       parent_->web_layer_.replaceChild(web_layer_, new_layer);
     }
     web_layer_ = new_layer;
     web_layer_is_accelerated_ = layer_updated_externally_;
     for (size_t i = 0; i < children_.size(); ++i) {
       DCHECK(!children_[i]->web_layer_.isNull());
@@ skipping 100 matching lines @@
                           WebKit::WebRect& opaque) {
 #endif
   TRACE_EVENT0("ui", "Layer::paintContents");
   gfx::Canvas canvas(web_canvas,
       ui::GetScaleFactorFromScale(device_scale_factor_), scale_content_);
 
   if (delegate_)
     delegate_->OnPaintLayer(&canvas);
 }
 
+unsigned Layer::prepareTexture(WebKit::WebTextureUpdater& /* updater */) {
+  DCHECK(layer_updated_externally_);
+  return texture_->texture_id();
+}
+
+WebKit::WebGraphicsContext3D* Layer::context() {
+  DCHECK(layer_updated_externally_);
+  return texture_->HostContext3D();
+}
+
 void Layer::SetForceRenderSurface(bool force) {
   if (force_render_surface_ == force)
     return;
 
   force_render_surface_ = force;
   web_layer_.setForceRenderSurface(force_render_surface_);
 }
 
 float Layer::GetCombinedOpacity() const {
   float opacity = opacity_;
@@ skipping 179 matching lines @@
 
 void Layer::RecomputeDrawsContentAndUVRect() {
   DCHECK(!web_layer_.isNull());
   bool should_draw = type_ != LAYER_NOT_DRAWN;
   if (!web_layer_is_accelerated_) {
     if (type_ != LAYER_SOLID_COLOR)
       web_layer_.to<WebKit::WebContentLayer>().setDrawsContent(should_draw);
     web_layer_.setBounds(ConvertSizeToPixel(this, bounds_.size()));
   } else {
     DCHECK(texture_);
-    unsigned int texture_id = texture_->texture_id();
     WebKit::WebExternalTextureLayer texture_layer =
         web_layer_.to<WebKit::WebExternalTextureLayer>();
-    texture_layer.setTextureId(should_draw ? texture_id : 0);
 
     gfx::Size texture_size;
     if (scale_content_)
       texture_size = texture_->size();
     else
       texture_size = ConvertSizeToDIP(this, texture_->size());
 
     gfx::Size size(std::min(bounds().width(), texture_size.width()),
                    std::min(bounds().height(), texture_size.height()));
     WebKit::WebFloatRect rect(
@@ skipping 13 matching lines @@
     return;
   unsigned int color = 0xFF000000;
   color |= web_layer_is_accelerated_ ? 0x0000FF00 : 0x00FF0000;
   bool opaque = fills_bounds_opaquely_ && (GetCombinedOpacity() == 1.f);
   if (!opaque)
     color |= 0xFF;
   web_layer_.setDebugBorderColor(color);
 }
 
 }  // namespace ui