Run all LayerTreeHost tests with a delegating renderer.

cc/resources/video_resource_updater.cc

 // Copyright 2013 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/resources/video_resource_updater.h"
 
 #include "base/bind.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/resources/resource_provider.h"
 #include "gpu/GLES2/gl2extchromium.h"
@@ skipping 11 matching lines @@
 VideoFrameExternalResources::VideoFrameExternalResources()
     : type(NONE), hardware_resource(0) {}
 
 VideoFrameExternalResources::~VideoFrameExternalResources() {}
 
 VideoResourceUpdater::VideoResourceUpdater(ResourceProvider* resource_provider)
     : resource_provider_(resource_provider) {
 }
 
 VideoResourceUpdater::~VideoResourceUpdater() {
-  while (!recycled_resources_.empty()) {
-    resource_provider_->DeleteResource(recycled_resources_.back().resource_id);
-    recycled_resources_.pop_back();
+  while (!all_resources_.empty()) {
+    resource_provider_->DeleteResource(all_resources_.back());
+    all_resources_.pop_back();
   }
 }
 
 bool VideoResourceUpdater::VerifyFrame(
     const scoped_refptr<media::VideoFrame>& video_frame) {
   // If these fail, we'll have to add logic that handles offset bitmap/texture
   // UVs. For now, just expect (0, 0) offset, since all our decoders so far
   // don't offset.
   DCHECK_EQ(video_frame->visible_rect().x(), 0);
   DCHECK_EQ(video_frame->visible_rect().y(), 0);
@@ skipping 124 matching lines @@
       }
     }
 
     if (resource_id == 0) {
       // TODO(danakj): Abstract out hw/sw resource create/delete from
       // ResourceProvider and stop using ResourceProvider in this class.
       resource_id =
           resource_provider_->CreateResource(output_plane_resource_size,
                                              output_resource_format,
                                              ResourceProvider::TextureUsageAny);
+      if (resource_id)
+        all_resources_.push_back(resource_id);
     }
 
     if (resource_id == 0) {
       allocation_success = false;
       break;
     }
 
     plane_resources.push_back(PlaneResource(resource_id,
                                             output_plane_resource_size,
                                             output_resource_format,
@@ skipping 134 matching lines @@
       break;
     default:
       NOTREACHED();
       return VideoFrameExternalResources();
   }
 
   external_resources.hardware_resource =
       resource_provider_->CreateResourceFromExternalTexture(
           video_frame->texture_target(),
           video_frame->texture_id());
+  if (external_resources.hardware_resource)
+    all_resources_.push_back(external_resources.hardware_resource);
 
   TextureMailbox::ReleaseCallback callback_to_return_resource =
       base::Bind(&ReturnTexture,
+                 AsWeakPtr(),
                  base::Unretained(resource_provider_),
                  external_resources.hardware_resource);
   external_resources.hardware_release_callback = callback_to_return_resource;
   return external_resources;
 }
 
 // static
 void VideoResourceUpdater::ReturnTexture(
+    base::WeakPtr<VideoResourceUpdater> updater,
     ResourceProvider* resource_provider,
     unsigned resource_id,
     unsigned sync_point,
     bool lost_resource) {
+  if (!updater) {
+    // Resource was already deleted.
+    return;
+  }
+
   resource_provider->DeleteResource(resource_id);
+  std::vector<unsigned>& all_resources = updater->all_resources_;
+  all_resources.erase(std::remove(all_resources.begin(),
+                                  all_resources.end(),
+                                  resource_id));
 }
 
 // static
 void VideoResourceUpdater::RecycleResource(
     base::WeakPtr<VideoResourceUpdater> updater,
     ResourceProvider* resource_provider,
     RecycleResourceData data,
     unsigned sync_point,
     bool lost_resource) {
+  if (!updater) {
+    // Resource was already deleted.
+    return;
+  }
+
   WebKit::WebGraphicsContext3D* context =
       resource_provider->GraphicsContext3D();
   if (context && sync_point)
-      GLC(context, context->waitSyncPoint(sync_point));
+    GLC(context, context->waitSyncPoint(sync_point));
   if (context && !lost_resource) {
     ResourceProvider::ScopedWriteLockGL lock(resource_provider,
                                              data.resource_id);
     GLC(context, context->bindTexture(GL_TEXTURE_2D, lock.texture_id()));
     GLC(context, context->consumeTextureCHROMIUM(GL_TEXTURE_2D,
                                                  data.mailbox.name));
     GLC(context, context->bindTexture(GL_TEXTURE_2D, 0));
   }
 
-  if (!updater || lost_resource) {
+  if (lost_resource) {
     resource_provider->DeleteResource(data.resource_id);
+    std::vector<unsigned>& all_resources = updater->all_resources_;
+    all_resources.erase(std::remove(all_resources.begin(),
+                                    all_resources.end(),
+                                    data.resource_id));
     return;
   }
 
   // Drop recycled resources that are the wrong format.
   while (!updater->recycled_resources_.empty() &&
          updater->recycled_resources_.back().resource_format !=
          data.resource_format) {
     resource_provider->DeleteResource(
         updater->recycled_resources_.back().resource_id);
     updater->recycled_resources_.pop_back();
   }
 
   PlaneResource recycled_resource(data.resource_id,
                                   data.resource_size,
                                   data.resource_format,
                                   sync_point);
   updater->recycled_resources_.push_back(recycled_resource);
 }
 
 }  // namespace cc