cc: check valid thread and resource origin for the resource rasterized.

cc/resources/resource_provider.cc

 // Copyright 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 "cc/resources/resource_provider.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/containers/hash_tables.h"
@@ skipping 710 matching lines @@
     DCHECK_EQ(Bitmap, resource->type);
     delete resource->shared_bitmap;
     resource->pixels = NULL;
   }
   if (resource->pixels) {
     DCHECK(resource->origin == Resource::Internal);
     delete[] resource->pixels;
     resource->pixels = NULL;
   }
   if (resource->gpu_memory_buffer) {
-    DCHECK(resource->origin != Resource::External);
+    DCHECK(resource->origin == Resource::Internal);
     delete resource->gpu_memory_buffer;
     resource->gpu_memory_buffer = NULL;
   }
   resources_.erase(it);
 }
 
 ResourceProvider::ResourceType ResourceProvider::GetResourceType(
     ResourceId id) {
   return GetResource(id)->type;
 }
@@ skipping 299 matching lines @@
       gpu_memory_buffer_manager_(resource_provider->gpu_memory_buffer_manager_),
       gpu_memory_buffer_(nullptr),
       size_(resource_->size),
       format_(resource_->format) {
   DCHECK_EQ(GLTexture, resource_->type);
   std::swap(gpu_memory_buffer_, resource_->gpu_memory_buffer);
 }
 
 ResourceProvider::ScopedWriteLockGpuMemoryBuffer::
     ~ScopedWriteLockGpuMemoryBuffer() {
+  DCHECK(thread_checker_.CalledOnValidThread());

[reveman, 2014/10/29 21:08:26]

No need to use DCHECK. This is already handled by the ThreadChecker
implementation.

[dshwang, 2014/10/30 05:58:12]

DCHECK is needed when checking thread_checker_.CalledOnValidThread()

   resource_provider_->UnlockForWrite(resource_);
   if (!gpu_memory_buffer_)
     return;
 
   if (!resource_->image_id) {
     GLES2Interface* gl = resource_provider_->ContextGL();
     DCHECK(gl);
 
     resource_->image_id =
         gl->CreateImageCHROMIUM(gpu_memory_buffer_->AsClientBuffer(),
                                 size_.width(),
                                 size_.height(),
                                 GL_RGBA);
   }
 
   std::swap(resource_->gpu_memory_buffer, gpu_memory_buffer_);
   resource_->allocated = true;
   resource_->dirty_image = true;
 
   // GpuMemoryBuffer provides direct access to the memory used by the GPU.
   // Read lock fences are required to ensure that we're not trying to map a
   // buffer that is currently in-use by the GPU.
   resource_->read_lock_fences_enabled = true;
 }
 
 gfx::GpuMemoryBuffer*
 ResourceProvider::ScopedWriteLockGpuMemoryBuffer::GetGpuMemoryBuffer() {
+  DCHECK(!thread_checker_.CalledOnValidThread());

[reveman, 2014/10/29 21:08:26]

This will fail. GetGpuMemoryBuffer is allowed to be called on a worker thread.

[dshwang, 2014/10/30 05:58:12]

There is ! inside DCHECK. I change it to "DCHECK_EQ(false,
thread_checker_.CalledOnValidThread());" to read it easily.

   if (!gpu_memory_buffer_) {
     scoped_ptr<gfx::GpuMemoryBuffer> gpu_memory_buffer =
         gpu_memory_buffer_manager_->AllocateGpuMemoryBuffer(
             size_, ToGpuMemoryBufferFormat(format_), gfx::GpuMemoryBuffer::MAP);
     gpu_memory_buffer_ = gpu_memory_buffer.release();
   }
 
   return gpu_memory_buffer_;
 }
 
 ResourceProvider::ScopedWriteLockGr::ScopedWriteLockGr(
     ResourceProvider* resource_provider,
     ResourceProvider::ResourceId resource_id)
     : resource_provider_(resource_provider),
       resource_(resource_provider->LockForWrite(resource_id)) {
 }
 
 ResourceProvider::ScopedWriteLockGr::~ScopedWriteLockGr() {
+  DCHECK(thread_checker_.CalledOnValidThread());

[reveman, 2014/10/29 21:08:26]

No need to use DCHECK.

   resource_provider_->UnlockForWrite(resource_);
 }
 
 SkSurface* ResourceProvider::ScopedWriteLockGr::GetSkSurface(
     bool use_distance_field_text) {
+  DCHECK(thread_checker_.CalledOnValidThread());

[reveman, 2014/10/29 21:08:26]

No need to use DCHECK.

   DCHECK(resource_->locked_for_write);
 
   // If the surface doesn't exist, or doesn't have the correct dff setting,
   // recreate the surface within the resource.
   if (!resource_->sk_surface ||
       use_distance_field_text !=
           resource_->sk_surface->props().isUseDistanceFieldFonts()) {
     class GrContext* gr_context = resource_provider_->GrContext();
     // TODO(alokp): Implement TestContextProvider::GrContext().
     if (!gr_context)
@@ skipping 966 matching lines @@
   ContextProvider* context_provider = output_surface_->context_provider();
   return context_provider ? context_provider->ContextGL() : NULL;
 }
 
 class GrContext* ResourceProvider::GrContext() const {
   ContextProvider* context_provider = output_surface_->context_provider();
   return context_provider ? context_provider->GrContext() : NULL;
 }
 
 }  // namespace cc