cc: Remove TextureUploader.

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"
 #include "base/metrics/histogram.h"
 #include "base/numerics/safe_math.h"
 #include "base/stl_util.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/math_util.h"
 #include "cc/resources/platform_color.h"
 #include "cc/resources/returned_resource.h"
 #include "cc/resources/shared_bitmap_manager.h"
-#include "cc/resources/texture_uploader.h"
 #include "cc/resources/transferable_resource.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 #include "third_party/skia/include/gpu/GrTextureProvider.h"
 #include "ui/gfx/geometry/rect.h"
@@ skipping 22 matching lines @@
   }
 
   GLES2Interface* gl_;
   const size_t id_allocation_chunk_size_;
   scoped_ptr<GLuint[]> ids_;
   size_t next_id_index_;
 };
 
 namespace {
 
-// Measured in seconds.
-const double kSoftwareUploadTickRate = 0.000250;
-const double kTextureUploadTickRate = 0.004;
-
 GLenum TextureToStorageFormat(ResourceFormat format) {
   GLenum storage_format = GL_RGBA8_OES;
   switch (format) {
     case RGBA_8888:
       break;
     case BGRA_8888:
       storage_format = GL_BGRA8_EXT;
       break;
     case RGBA_4444:
     case ALPHA_8:
@@ skipping 333 matching lines @@
 ResourceProvider::~ResourceProvider() {
   while (!children_.empty())
     DestroyChildInternal(children_.begin(), FOR_SHUTDOWN);
   while (!resources_.empty())
     DeleteResourceInternal(resources_.begin(), FOR_SHUTDOWN);
 
   GLES2Interface* gl = ContextGL();
   if (default_resource_type_ != RESOURCE_TYPE_GL_TEXTURE) {
     // We are not in GL mode, but double check before returning.
     DCHECK(!gl);
-    DCHECK(!texture_uploader_);
     return;
   }
 
   DCHECK(gl);
 #if DCHECK_IS_ON()
   // Check that all GL resources has been deleted.
   for (ResourceMap::const_iterator itr = resources_.begin();
        itr != resources_.end(); ++itr) {
     DCHECK_NE(RESOURCE_TYPE_GL_TEXTURE, itr->second.type);
   }
 #endif  // DCHECK_IS_ON()
 
-  texture_uploader_ = nullptr;
   texture_id_allocator_ = nullptr;
   buffer_id_allocator_ = nullptr;
   gl->Finish();
 }
 
 bool ResourceProvider::InUseByConsumer(ResourceId id) {
   Resource* resource = GetResource(id);
   return resource->lock_for_read_count > 0 || resource->exported_count > 0 ||
          resource->lost;
 }
@@ skipping 239 matching lines @@
     resource->gpu_memory_buffer = NULL;
   }
   resources_.erase(it);
 }
 
 ResourceProvider::ResourceType ResourceProvider::GetResourceType(
     ResourceId id) {
   return GetResource(id)->type;
 }
 
-void ResourceProvider::SetPixels(ResourceId id,
-                                 const uint8_t* image,
-                                 const gfx::Rect& image_rect,
-                                 const gfx::Rect& source_rect,
-                                 const gfx::Vector2d& dest_offset) {
-  Resource* resource = GetResource(id);
-  DCHECK(!resource->locked_for_write);
-  DCHECK(!resource->lock_for_read_count);
-  DCHECK(resource->origin == Resource::INTERNAL);
-  DCHECK_EQ(resource->exported_count, 0);
-  DCHECK(ReadLockFenceHasPassed(resource));
-  LazyAllocate(resource);
-
-  if (resource->type == RESOURCE_TYPE_GL_TEXTURE) {
-    DCHECK(resource->gl_id);
-    DCHECK(!resource->pending_set_pixels);
-    DCHECK_EQ(resource->target, static_cast<GLenum>(GL_TEXTURE_2D));
-    GLES2Interface* gl = ContextGL();
-    DCHECK(gl);
-    DCHECK(texture_uploader_.get());
-    gl->BindTexture(GL_TEXTURE_2D, resource->gl_id);
-    texture_uploader_->Upload(image,
-                              image_rect,
-                              source_rect,
-                              dest_offset,
-                              resource->format,
-                              resource->size);
-  } else {
-    DCHECK_EQ(RESOURCE_TYPE_BITMAP, resource->type);
-    DCHECK(resource->allocated);
-    DCHECK_EQ(RGBA_8888, resource->format);
-    DCHECK(source_rect.x() >= image_rect.x());
-    DCHECK(source_rect.y() >= image_rect.y());
-    DCHECK(source_rect.right() <= image_rect.right());
-    DCHECK(source_rect.bottom() <= image_rect.bottom());
-    SkImageInfo source_info =
-        SkImageInfo::MakeN32Premul(source_rect.width(), source_rect.height());
-    size_t image_row_bytes = image_rect.width() * 4;
-    gfx::Vector2d source_offset = source_rect.origin() - image_rect.origin();
-    image += source_offset.y() * image_row_bytes + source_offset.x() * 4;
-
-    ScopedWriteLockSoftware lock(this, id);
-    SkCanvas dest(lock.sk_bitmap());
-    dest.writePixels(source_info, image, image_row_bytes, dest_offset.x(),
-                     dest_offset.y());
-  }
-}
-
 void ResourceProvider::CopyToResource(ResourceId id,
                                       const uint8_t* image,
                                       const gfx::Size& image_size) {
   Resource* resource = GetResource(id);
   DCHECK(!resource->locked_for_write);
   DCHECK(!resource->lock_for_read_count);
   DCHECK(resource->origin == Resource::INTERNAL);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(ReadLockFenceHasPassed(resource));
   LazyAllocate(resource);
@@ skipping 11 matching lines @@
 
     ScopedWriteLockSoftware lock(this, id);
     SkCanvas dest(lock.sk_bitmap());
     dest.writePixels(source_info, image, image_stride, 0, 0);
   } else {
     DCHECK(resource->gl_id);
     DCHECK(!resource->pending_set_pixels);
     DCHECK_EQ(resource->target, static_cast<GLenum>(GL_TEXTURE_2D));
     GLES2Interface* gl = ContextGL();
     DCHECK(gl);
-    DCHECK(texture_uploader_.get());
     gl->BindTexture(GL_TEXTURE_2D, resource->gl_id);
 
     if (resource->format == ETC1) {
       base::CheckedNumeric<int> num_bytes = BitsPerPixel(ETC1);
       num_bytes *= image_size.width();
       num_bytes *= image_size.height();
       num_bytes /= 8;
       gl->CompressedTexImage2D(GL_TEXTURE_2D, 0, GLInternalFormat(ETC1),
                                image_size.width(), image_size.height(), 0,
                                num_bytes.ValueOrDie(), image);
     } else {
       gl->TexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, image_size.width(),
                         image_size.height(), GLDataFormat(resource->format),
                         GLDataType(resource->format), image);
     }
   }
 }
 
-size_t ResourceProvider::NumBlockingUploads() {
-  if (!texture_uploader_)
-    return 0;
-
-  return texture_uploader_->NumBlockingUploads();
-}
-
-void ResourceProvider::MarkPendingUploadsAsNonBlocking() {
-  if (!texture_uploader_)
-    return;
-
-  texture_uploader_->MarkPendingUploadsAsNonBlocking();
-}
-
-size_t ResourceProvider::EstimatedUploadsPerTick() {
-  if (!texture_uploader_)
-    return 1u;
-
-  double textures_per_second = texture_uploader_->EstimatedTexturesPerSecond();
-  size_t textures_per_tick = floor(
-      kTextureUploadTickRate * textures_per_second);
-  return textures_per_tick ? textures_per_tick : 1u;
-}
-
-void ResourceProvider::FlushUploads() {
-  if (!texture_uploader_)
-    return;
-
-  texture_uploader_->Flush();
-}
-
-void ResourceProvider::ReleaseCachedData() {
-  if (!texture_uploader_)
-    return;
-
-  texture_uploader_->ReleaseCachedQueries();
-}
-
-base::TimeTicks ResourceProvider::EstimatedUploadCompletionTime(
-    size_t uploads_per_tick) {
-  if (lost_output_surface_)
-    return base::TimeTicks();
-
-  // Software resource uploads happen on impl thread, so don't bother batching
-  // them up and trying to wait for them to complete.
-  if (!texture_uploader_) {
-    return base::TimeTicks::Now() +
-           base::TimeDelta::FromMicroseconds(
-               base::Time::kMicrosecondsPerSecond * kSoftwareUploadTickRate);
-  }
-
-  base::TimeDelta upload_one_texture_time =
-      base::TimeDelta::FromMicroseconds(
-          base::Time::kMicrosecondsPerSecond * kTextureUploadTickRate) /
-      uploads_per_tick;
-
-  size_t total_uploads = NumBlockingUploads() + uploads_per_tick;
-  return base::TimeTicks::Now() + upload_one_texture_time * total_uploads;
-}
-
 ResourceProvider::Resource* ResourceProvider::InsertResource(
     ResourceId id,
     const Resource& resource) {
   std::pair<ResourceMap::iterator, bool> result =
       resources_.insert(ResourceMap::value_type(id, resource));
   DCHECK(result.second);
   return &result.first->second;
 }
 
 ResourceProvider::Resource* ResourceProvider::GetResource(ResourceId id) {
@@ skipping 366 matching lines @@
 
   GLES2Interface* gl = ContextGL();
   if (!gl) {
     default_resource_type_ = RESOURCE_TYPE_BITMAP;
     // Pick an arbitrary limit here similar to what hardware might.
     max_texture_size_ = 16 * 1024;
     best_texture_format_ = RGBA_8888;
     return;
   }
 
-  DCHECK(!texture_uploader_);
   DCHECK(!texture_id_allocator_);
   DCHECK(!buffer_id_allocator_);
 
   const ContextProvider::Capabilities& caps =
       output_surface_->context_provider()->ContextCapabilities();
 
   default_resource_type_ = RESOURCE_TYPE_GL_TEXTURE;
   use_texture_storage_ext_ = caps.gpu.texture_storage;
   use_texture_format_bgra_ = caps.gpu.texture_format_bgra8888;
   use_texture_usage_hint_ = caps.gpu.texture_usage;
   use_compressed_texture_etc1_ = caps.gpu.texture_format_etc1;
   yuv_resource_format_ = caps.gpu.texture_rg ? RED_8 : LUMINANCE_8;
   use_sync_query_ = caps.gpu.sync_query;
 
-  texture_uploader_ = TextureUploader::Create(gl);
   max_texture_size_ = 0;  // Context expects cleared value.
   gl->GetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size_);
   best_texture_format_ =
       PlatformColor::BestTextureFormat(use_texture_format_bgra_);
 
   texture_id_allocator_.reset(
       new TextureIdAllocator(gl, id_allocation_chunk_size_));
   buffer_id_allocator_.reset(
       new BufferIdAllocator(gl, id_allocation_chunk_size_));
 }
@@ skipping 794 matching lines @@
 }
 
 class GrContext* ResourceProvider::GrContext(bool worker_context) const {
   ContextProvider* context_provider =
       worker_context ? output_surface_->worker_context_provider()
                      : output_surface_->context_provider();
   return context_provider ? context_provider->GrContext() : NULL;
 }
 
 }  // namespace cc