Remove old texture path in TextureLayer

cc/layers/texture_layer_impl.cc

Index: cc/layers/texture_layer_impl.cc
diff --git a/cc/layers/texture_layer_impl.cc b/cc/layers/texture_layer_impl.cc
index 6bccde4a6a5a3aad00156472dc771a5c30b7632e..ec30a3b2222f14439047db6fde0343e7b7562a5f 100644
--- a/cc/layers/texture_layer_impl.cc
+++ b/cc/layers/texture_layer_impl.cc
@@ -18,17 +18,14 @@
 namespace cc {
 
 TextureLayerImpl::TextureLayerImpl(LayerTreeImpl* tree_impl,
-                                   int id,
-                                   bool uses_mailbox)
+                                   int id)
     : LayerImpl(tree_impl, id),
-      texture_id_(0),
       external_texture_resource_(0),
       premultiplied_alpha_(true),
       blend_background_color_(false),
       flipped_(true),
       uv_top_left_(0.f, 0.f),
       uv_bottom_right_(1.f, 1.f),
-      uses_mailbox_(uses_mailbox),
       own_mailbox_(false),
       valid_texture_copy_(false) {
   vertex_opacity_[0] = 1.0f;
@@ -42,7 +39,6 @@ TextureLayerImpl::~TextureLayerImpl() { FreeTextureMailbox(); }
 void TextureLayerImpl::SetTextureMailbox(
     const TextureMailbox& mailbox,
     scoped_ptr<SingleReleaseCallback> release_callback) {
-  DCHECK(uses_mailbox_);
   DCHECK_EQ(mailbox.IsValid(), !!release_callback);
   FreeTextureMailbox();
   texture_mailbox_ = mailbox;
@@ -54,8 +50,7 @@ void TextureLayerImpl::SetTextureMailbox(
 
 scoped_ptr<LayerImpl> TextureLayerImpl::CreateLayerImpl(
     LayerTreeImpl* tree_impl) {
-  return TextureLayerImpl::Create(tree_impl, id(), uses_mailbox_).
-      PassAs<LayerImpl>();
+  return TextureLayerImpl::Create(tree_impl, id()).PassAs<LayerImpl>();
 }
 
 void TextureLayerImpl::PushPropertiesTo(LayerImpl* layer) {
@@ -68,12 +63,10 @@ void TextureLayerImpl::PushPropertiesTo(LayerImpl* layer) {
   texture_layer->SetVertexOpacity(vertex_opacity_);
   texture_layer->SetPremultipliedAlpha(premultiplied_alpha_);
   texture_layer->SetBlendBackgroundColor(blend_background_color_);
-  if (uses_mailbox_ && own_mailbox_) {
+  if (own_mailbox_) {
     texture_layer->SetTextureMailbox(texture_mailbox_,
                                      release_callback_.Pass());
     own_mailbox_ = false;
-  } else {
-    texture_layer->SetTextureId(texture_id_);
   }
 }
 
@@ -82,76 +75,66 @@ bool TextureLayerImpl::WillDraw(DrawMode draw_mode,
   if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE)
     return false;
 
-  if (uses_mailbox_) {
-    if (own_mailbox_) {
-      DCHECK(!external_texture_resource_);
-      if ((draw_mode == DRAW_MODE_HARDWARE && texture_mailbox_.IsTexture()) ||
-          (draw_mode == DRAW_MODE_SOFTWARE &&
-           texture_mailbox_.IsSharedMemory())) {
-        external_texture_resource_ =
-            resource_provider->CreateResourceFromTextureMailbox(
-                texture_mailbox_,
-                release_callback_.Pass());
-        DCHECK(external_texture_resource_);
-        texture_copy_.reset();
-        valid_texture_copy_ = false;
-      }
-      if (external_texture_resource_)
-        own_mailbox_ = false;
+  if (own_mailbox_) {
+    DCHECK(!external_texture_resource_);
+    if ((draw_mode == DRAW_MODE_HARDWARE && texture_mailbox_.IsTexture()) ||
+        (draw_mode == DRAW_MODE_SOFTWARE &&
+         texture_mailbox_.IsSharedMemory())) {
+      external_texture_resource_ =
+          resource_provider->CreateResourceFromTextureMailbox(
+              texture_mailbox_,
+              release_callback_.Pass());
+      DCHECK(external_texture_resource_);
+      texture_copy_.reset();
+      valid_texture_copy_ = false;
     }
+    if (external_texture_resource_)
+      own_mailbox_ = false;
+  }
 
-    if (!valid_texture_copy_ && draw_mode == DRAW_MODE_HARDWARE &&
-        texture_mailbox_.IsSharedMemory()) {
-      DCHECK(!external_texture_resource_);
-      // Have to upload a copy to a texture for it to be used in a
-      // hardware draw.
-      if (!texture_copy_)
-        texture_copy_ = ScopedResource::Create(resource_provider);
-      if (texture_copy_->size() != texture_mailbox_.shared_memory_size() ||
-          resource_provider->InUseByConsumer(texture_copy_->id()))
-        texture_copy_->Free();
-
-      if (!texture_copy_->id()) {
-        texture_copy_->Allocate(texture_mailbox_.shared_memory_size(),
-                                ResourceProvider::TextureUsageAny,
-                                resource_provider->best_texture_format());
-      }
+  if (!valid_texture_copy_ && draw_mode == DRAW_MODE_HARDWARE &&
+      texture_mailbox_.IsSharedMemory()) {
+    DCHECK(!external_texture_resource_);
+    // Have to upload a copy to a texture for it to be used in a
+    // hardware draw.
+    if (!texture_copy_)
+      texture_copy_ = ScopedResource::Create(resource_provider);
+    if (texture_copy_->size() != texture_mailbox_.shared_memory_size() ||
+        resource_provider->InUseByConsumer(texture_copy_->id()))
+      texture_copy_->Free();
+
+    if (!texture_copy_->id()) {
+      texture_copy_->Allocate(texture_mailbox_.shared_memory_size(),
+                              ResourceProvider::TextureUsageAny,
+                              resource_provider->best_texture_format());
+    }
 
-      if (texture_copy_->id()) {
-        std::vector<uint8> swizzled;
-        uint8* pixels =
-            static_cast<uint8*>(texture_mailbox_.shared_memory()->memory());
-
-        if (!PlatformColor::SameComponentOrder(texture_copy_->format())) {
-          // Swizzle colors. This is slow, but should be really uncommon.
-          size_t bytes = texture_mailbox_.SharedMemorySizeInBytes();
-          swizzled.resize(bytes);
-          for (size_t i = 0; i < bytes; i += 4) {
-            swizzled[i] = pixels[i + 2];
-            swizzled[i + 1] = pixels[i + 1];
-            swizzled[i + 2] = pixels[i];
-            swizzled[i + 3] = pixels[i + 3];
-          }
-          pixels = &swizzled[0];
+    if (texture_copy_->id()) {
+      std::vector<uint8> swizzled;
+      uint8* pixels =
+          static_cast<uint8*>(texture_mailbox_.shared_memory()->memory());
+
+      if (!PlatformColor::SameComponentOrder(texture_copy_->format())) {
+        // Swizzle colors. This is slow, but should be really uncommon.
+        size_t bytes = texture_mailbox_.SharedMemorySizeInBytes();
+        swizzled.resize(bytes);
+        for (size_t i = 0; i < bytes; i += 4) {
+          swizzled[i] = pixels[i + 2];
+          swizzled[i + 1] = pixels[i + 1];
+          swizzled[i + 2] = pixels[i];
+          swizzled[i + 3] = pixels[i + 3];
         }
+        pixels = &swizzled[0];
+      }
 
-        resource_provider->SetPixels(
-            texture_copy_->id(),
-            pixels,
-            gfx::Rect(texture_mailbox_.shared_memory_size()),
-            gfx::Rect(texture_mailbox_.shared_memory_size()),
-            gfx::Vector2d());
+      resource_provider->SetPixels(
+          texture_copy_->id(),
+          pixels,
+          gfx::Rect(texture_mailbox_.shared_memory_size()),
+          gfx::Rect(texture_mailbox_.shared_memory_size()),
+          gfx::Vector2d());
 
-        valid_texture_copy_ = true;
-      }
-    }
-  } else if (texture_id_) {
-    DCHECK(!external_texture_resource_);
-    if (draw_mode == DRAW_MODE_HARDWARE) {
-      external_texture_resource_ =
-          resource_provider->CreateResourceFromExternalTexture(
-              GL_TEXTURE_2D,
-              texture_id_);
+      valid_texture_copy_ = true;
     }
   }
   return (external_texture_resource_ || valid_texture_copy_) &&
@@ -194,18 +177,6 @@ void TextureLayerImpl::AppendQuads(QuadSink* quad_sink,
   quad_sink->Append(quad.PassAs<DrawQuad>());
 }
 
-void TextureLayerImpl::DidDraw(ResourceProvider* resource_provider) {
-  LayerImpl::DidDraw(resource_provider);
-  if (uses_mailbox_ || !external_texture_resource_)
-    return;
-  // TODO(danakj): the following assert will not be true when sending resources
-  // to a parent compositor. A synchronization scheme (double-buffering or
-  // pipelining of updates) for the client will need to exist to solve this.
-  DCHECK(!resource_provider->InUseByConsumer(external_texture_resource_));
-  resource_provider->DeleteResource(external_texture_resource_);
-  external_texture_resource_ = 0;
-}
-
 Region TextureLayerImpl::VisibleContentOpaqueRegion() const {
   if (contents_opaque())
     return visible_content_rect();
@@ -217,24 +188,12 @@ Region TextureLayerImpl::VisibleContentOpaqueRegion() const {
 }
 
 void TextureLayerImpl::ReleaseResources() {
-  if (external_texture_resource_ && !uses_mailbox_) {
-    ResourceProvider* resource_provider =
-        layer_tree_impl()->resource_provider();
-    resource_provider->DeleteResource(external_texture_resource_);
-  } else {
-    FreeTextureMailbox();
-  }
+  FreeTextureMailbox();
   texture_copy_.reset();
-  texture_id_ = 0;
   external_texture_resource_ = 0;
   valid_texture_copy_ = false;
 }
 
-void TextureLayerImpl::SetTextureId(unsigned id) {
-  texture_id_ = id;
-  SetNeedsPushProperties();
-}
-
 void TextureLayerImpl::SetPremultipliedAlpha(bool premultiplied_alpha) {
   premultiplied_alpha_ = premultiplied_alpha;
   SetNeedsPushProperties();
@@ -276,8 +235,6 @@ const char* TextureLayerImpl::LayerTypeAsString() const {
 }
 
 void TextureLayerImpl::FreeTextureMailbox() {
-  if (!uses_mailbox_)
-    return;
   if (own_mailbox_) {
     DCHECK(!external_texture_resource_);
     if (release_callback_)