Fix use_image_texture_target inconsistencies

cc/raster/one_copy_raster_buffer_provider.cc

 // Copyright 2014 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/raster/one_copy_raster_buffer_provider.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 201 matching lines @@
     const RasterSource::PlaybackSettings& playback_settings,
     uint64_t previous_content_id,
     uint64_t new_content_id) {
   // Allocate GpuMemoryBuffer if necessary. If using partial raster, we
   // must allocate a buffer with BufferUsage CPU_READ_WRITE_PERSISTENT.
   if (!staging_buffer->gpu_memory_buffer) {
     staging_buffer->gpu_memory_buffer =
         resource_provider_->gpu_memory_buffer_manager()
             ->AllocateGpuMemoryBuffer(
                 staging_buffer->size, BufferFormat(resource->format()),
-                use_partial_raster_
-                    ? gfx::BufferUsage::GPU_READ_CPU_READ_WRITE_PERSISTENT
-                    : gfx::BufferUsage::GPU_READ_CPU_READ_WRITE,
-                gpu::kNullSurfaceHandle);
+                StagingBufferUsage(), gpu::kNullSurfaceHandle);
   }
 
   gfx::Rect playback_rect = raster_full_rect;
   if (use_partial_raster_ && previous_content_id) {
     // Reduce playback rect to dirty region if the content id of the staging
     // buffer matches the prevous content id.
     if (previous_content_id == staging_buffer->content_id)
       playback_rect.Intersect(raster_dirty_rect);
   }
 
@@ skipping 40 matching lines @@
     uint64_t new_content_id) {
   ContextProvider::ScopedContextLock scoped_context(worker_context_provider_);
   gpu::gles2::GLES2Interface* gl = scoped_context.ContextGL();
   DCHECK(gl);
 
   // Create texture after synchronizing with compositor.
   ResourceProvider::ScopedTextureProvider scoped_texture(
       gl, resource_lock, async_worker_context_enabled_);
 
   unsigned resource_texture_id = scoped_texture.texture_id();
-  unsigned image_target =
-      resource_provider_->GetImageTextureTarget(resource_lock->format());
+  unsigned image_target = resource_provider_->GetImageTextureTarget(
+      StagingBufferUsage(), staging_buffer->format);
 
   // Create and bind staging texture.
   if (!staging_buffer->texture_id) {
     gl->GenTextures(1, &staging_buffer->texture_id);
     gl->BindTexture(image_target, staging_buffer->texture_id);
     gl->TexParameteri(image_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     gl->TexParameteri(image_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     gl->TexParameteri(image_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     gl->TexParameteri(image_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
   } else {
@@ skipping 78 matching lines @@
   // Barrier to sync worker context output to cc context.
   gl->OrderingBarrierCHROMIUM();
 
   // Generate sync token after the barrier for cross context synchronization.
   gpu::SyncToken resource_sync_token;
   gl->GenUnverifiedSyncTokenCHROMIUM(fence_sync, resource_sync_token.GetData());
   resource_lock->set_sync_token(resource_sync_token);
   resource_lock->set_synchronized(!async_worker_context_enabled_);
 }
 
+gfx::BufferUsage OneCopyRasterBufferProvider::StagingBufferUsage() const {
+  return use_partial_raster_
+             ? gfx::BufferUsage::GPU_READ_CPU_READ_WRITE_PERSISTENT
+             : gfx::BufferUsage::GPU_READ_CPU_READ_WRITE;
+}
+
 }  // namespace cc