cc: Remove GLC macro

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/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/util.h"
-#include "cc/output/gl_renderer.h"  // For the GLC() macro.
 #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"
@@ skipping 106 matching lines @@
   return gfx::GpuMemoryBuffer::Format::RGBA_8888;
 }
 
 class ScopedSetActiveTexture {
  public:
   ScopedSetActiveTexture(GLES2Interface* gl, GLenum unit)
       : gl_(gl), unit_(unit) {
     DCHECK_EQ(GL_TEXTURE0, ResourceProvider::GetActiveTextureUnit(gl_));
 
     if (unit_ != GL_TEXTURE0)
-      GLC(gl_, gl_->ActiveTexture(unit_));
+      gl_->ActiveTexture(unit_);
   }
 
   ~ScopedSetActiveTexture() {
     // Active unit being GL_TEXTURE0 is effectively the ground state.
     if (unit_ != GL_TEXTURE0)
-      GLC(gl_, gl_->ActiveTexture(GL_TEXTURE0));
+      gl_->ActiveTexture(GL_TEXTURE0);
   }
 
  private:
   GLES2Interface* gl_;
   GLenum unit_;
 };
 
 class TextureIdAllocator : public IdAllocator {
  public:
   TextureIdAllocator(GLES2Interface* gl,
@@ skipping 474 matching lines @@
   bool lost_resource = resource->lost;
 
   DCHECK(resource->exported_count == 0 || style != NORMAL);
   if (style == FOR_SHUTDOWN && resource->exported_count > 0)
     lost_resource = true;
 
   if (resource->image_id) {
     DCHECK(resource->origin == Resource::INTERNAL);
     GLES2Interface* gl = ContextGL();
     DCHECK(gl);
-    GLC(gl, gl->DestroyImageCHROMIUM(resource->image_id));
+    gl->DestroyImageCHROMIUM(resource->image_id);
   }
   if (resource->gl_upload_query_id) {
     DCHECK(resource->origin == Resource::INTERNAL);
     GLES2Interface* gl = ContextGL();
     DCHECK(gl);
-    GLC(gl, gl->DeleteQueriesEXT(1, &resource->gl_upload_query_id));
+    gl->DeleteQueriesEXT(1, &resource->gl_upload_query_id);
   }
   if (resource->gl_read_lock_query_id) {
     DCHECK(resource->origin == Resource::INTERNAL);
     GLES2Interface* gl = ContextGL();
     DCHECK(gl);
-    GLC(gl, gl->DeleteQueriesEXT(1, &resource->gl_read_lock_query_id));
+    gl->DeleteQueriesEXT(1, &resource->gl_read_lock_query_id);
   }
   if (resource->gl_pixel_buffer_id) {
     DCHECK(resource->origin == Resource::INTERNAL);
     GLES2Interface* gl = ContextGL();
     DCHECK(gl);
-    GLC(gl, gl->DeleteBuffers(1, &resource->gl_pixel_buffer_id));
+    gl->DeleteBuffers(1, &resource->gl_pixel_buffer_id);
   }
   if (resource->origin == Resource::EXTERNAL) {
     DCHECK(resource->mailbox.IsValid());
     GLuint sync_point = resource->mailbox.sync_point();
     if (resource->type == RESOURCE_TYPE_GL_TEXTURE) {
       DCHECK(resource->mailbox.IsTexture());
       lost_resource |= lost_output_surface_;
       GLES2Interface* gl = ContextGL();
       DCHECK(gl);
       if (resource->gl_id) {
-        GLC(gl, gl->DeleteTextures(1, &resource->gl_id));
+        gl->DeleteTextures(1, &resource->gl_id);
         resource->gl_id = 0;
         if (!lost_resource)
           sync_point = gl->InsertSyncPointCHROMIUM();
       }
     } else {
       DCHECK(resource->mailbox.IsSharedMemory());
       resource->shared_bitmap = nullptr;
       resource->pixels = nullptr;
     }
     resource->release_callback_impl.Run(
         sync_point, lost_resource, blocking_main_thread_task_runner_);
   }
   if (resource->gl_id) {
     GLES2Interface* gl = ContextGL();
     DCHECK(gl);
-    GLC(gl, gl->DeleteTextures(1, &resource->gl_id));
+    gl->DeleteTextures(1, &resource->gl_id);
     resource->gl_id = 0;
   }
   if (resource->shared_bitmap) {
     DCHECK(resource->origin != Resource::EXTERNAL);
     DCHECK_EQ(RESOURCE_TYPE_BITMAP, resource->type);
     delete resource->shared_bitmap;
     resource->pixels = NULL;
   }
   if (resource->pixels) {
     DCHECK(resource->origin == Resource::INTERNAL);
@@ skipping 190 matching lines @@
   if (resource->type == RESOURCE_TYPE_GL_TEXTURE && !resource->gl_id) {
     DCHECK(resource->origin != Resource::INTERNAL);
     DCHECK(resource->mailbox.IsTexture());
 
     // Mailbox sync_points must be processed by a call to
     // WaitSyncPointIfNeeded() prior to calling LockForRead().
     DCHECK(!resource->mailbox.sync_point());
 
     GLES2Interface* gl = ContextGL();
     DCHECK(gl);
-    resource->gl_id =
-        GLC(gl, gl->CreateAndConsumeTextureCHROMIUM(resource->mailbox.target(),
-                                                    resource->mailbox.name()));
+    resource->gl_id = gl->CreateAndConsumeTextureCHROMIUM(
+        resource->mailbox.target(), resource->mailbox.name());
   }
 
   if (!resource->pixels && resource->has_shared_bitmap_id &&
       shared_bitmap_manager_) {
     scoped_ptr<SharedBitmap> bitmap =
         shared_bitmap_manager_->GetSharedBitmapFromId(
             resource->size, resource->shared_bitmap_id);
     if (bitmap) {
       resource->shared_bitmap = bitmap.release();
       resource->pixels = resource->shared_bitmap->pixels();
@@ skipping 346 matching lines @@
   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;
 
   GLES2Interface* gl = ContextGL();
   DCHECK(gl);
 
   texture_uploader_ = TextureUploader::Create(gl);
   max_texture_size_ = 0;  // Context expects cleared value.
-  GLC(gl, gl->GetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size_));
+  gl->GetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size_);
   best_texture_format_ = PlatformColor::BestTextureFormat(use_bgra);
 
   texture_id_allocator_.reset(
       new TextureIdAllocator(gl, id_allocation_chunk_size_));
   buffer_id_allocator_.reset(
       new BufferIdAllocator(gl, id_allocation_chunk_size_));
 }
 
 void ResourceProvider::CleanUpGLIfNeeded() {
   GLES2Interface* gl = ContextGL();
@@ skipping 240 matching lines @@
     if (resource->read_lock_fences_enabled) {
       if (current_read_lock_fence_.get())
         current_read_lock_fence_->Set();
       resource->read_lock_fence = current_read_lock_fence_;
     }
 
     if (returned.sync_point) {
       DCHECK(!resource->has_shared_bitmap_id);
       if (resource->origin == Resource::INTERNAL) {
         DCHECK(resource->gl_id);
-        GLC(gl, gl->WaitSyncPointCHROMIUM(returned.sync_point));
+        gl->WaitSyncPointCHROMIUM(returned.sync_point);
       } else {
         DCHECK(!resource->gl_id);
         resource->mailbox.set_sync_point(returned.sync_point);
       }
     }
 
     if (!resource->marked_for_deletion)
       continue;
 
     if (!resource->child_id) {
@@ skipping 50 matching lines @@
   } else if (!source->mailbox.IsValid()) {
     LazyCreate(source);
     DCHECK(source->gl_id);
     DCHECK(source->origin == Resource::INTERNAL);
     if (source->image_id) {
       DCHECK(source->dirty_image);
       BindImageForSampling(source);
     }
     // This is a resource allocated by the compositor, we need to produce it.
     // Don't set a sync point, the caller will do it.
-    GLC(gl, gl->GenMailboxCHROMIUM(resource->mailbox_holder.mailbox.name));
-    GLC(gl, gl->ProduceTextureDirectCHROMIUM(
-                source->gl_id, resource->mailbox_holder.texture_target,
-                resource->mailbox_holder.mailbox.name));
+    gl->GenMailboxCHROMIUM(resource->mailbox_holder.mailbox.name);
+    gl->ProduceTextureDirectCHROMIUM(source->gl_id,
+                                     resource->mailbox_holder.texture_target,
+                                     resource->mailbox_holder.mailbox.name);
 
     source->mailbox = TextureMailbox(resource->mailbox_holder);
   } else {
     DCHECK(source->mailbox.IsTexture());
     if (source->image_id && source->dirty_image) {
       DCHECK(source->gl_id);
       DCHECK(source->origin == Resource::INTERNAL);
-      GLC(gl,
-          gl->BindTexture(resource->mailbox_holder.texture_target,
-                          source->gl_id));
+      gl->BindTexture(resource->mailbox_holder.texture_target, source->gl_id);
       BindImageForSampling(source);
     }
     // This is either an external resource, or a compositor resource that we
     // already exported. Make sure to forward the sync point that we were given.
     resource->mailbox_holder.mailbox = source->mailbox.mailbox();
     resource->mailbox_holder.texture_target = source->mailbox.target();
     resource->mailbox_holder.sync_point = source->mailbox.sync_point();
     source->mailbox.set_sync_point(0);
   }
 }
@@ skipping 39 matching lines @@
       }
 
       // We still have an exported_count, so we'll have to lose it.
       is_lost = true;
     }
 
     if (gl && resource.filter != resource.original_filter) {
       DCHECK(resource.target);
       DCHECK(resource.gl_id);
 
-      GLC(gl, gl->BindTexture(resource.target, resource.gl_id));
-      GLC(gl,
-          gl->TexParameteri(resource.target,
-                            GL_TEXTURE_MIN_FILTER,
-                            resource.original_filter));
-      GLC(gl,
-          gl->TexParameteri(resource.target,
-                            GL_TEXTURE_MAG_FILTER,
-                            resource.original_filter));
+      gl->BindTexture(resource.target, resource.gl_id);
+      gl->TexParameteri(resource.target, GL_TEXTURE_MIN_FILTER,
+                        resource.original_filter);
+      gl->TexParameteri(resource.target, GL_TEXTURE_MAG_FILTER,
+                        resource.original_filter);
     }
 
     ReturnedResource returned;
     returned.id = child_id;
     returned.sync_point = resource.mailbox.sync_point();
     if (!returned.sync_point && resource.type == RESOURCE_TYPE_GL_TEXTURE)
       need_sync_point = true;
     returned.count = resource.imported_count;
     returned.lost = is_lost;
     to_return.push_back(returned);
@@ skipping 131 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   GLES2Interface* gl = ContextGL();
   ResourceMap::iterator it = resources_.find(resource_id);
   DCHECK(it != resources_.end());
   Resource* resource = &it->second;
   DCHECK(resource->lock_for_read_count);
   DCHECK(!resource->locked_for_write || resource->set_pixels_completion_forced);
 
   ScopedSetActiveTexture scoped_active_tex(gl, unit);
   GLenum target = resource->target;
-  GLC(gl, gl->BindTexture(target, resource->gl_id));
+  gl->BindTexture(target, resource->gl_id);
   if (filter != resource->filter) {
-    GLC(gl, gl->TexParameteri(target, GL_TEXTURE_MIN_FILTER, filter));
-    GLC(gl, gl->TexParameteri(target, GL_TEXTURE_MAG_FILTER, filter));
+    gl->TexParameteri(target, GL_TEXTURE_MIN_FILTER, filter);
+    gl->TexParameteri(target, GL_TEXTURE_MAG_FILTER, filter);
     resource->filter = filter;
   }
 
   if (resource->image_id && resource->dirty_image)
     BindImageForSampling(resource);
 
   return target;
 }
 
 void ResourceProvider::BeginSetPixels(ResourceId id) {
@@ skipping 59 matching lines @@
                "ResourceProvider::ForceSetPixelsToComplete");
 
   Resource* resource = GetResource(id);
 
   DCHECK(resource->locked_for_write);
   DCHECK(resource->pending_set_pixels);
   DCHECK(!resource->set_pixels_completion_forced);
 
   if (resource->gl_id) {
     GLES2Interface* gl = ContextGL();
-    GLC(gl, gl->BindTexture(GL_TEXTURE_2D, resource->gl_id));
-    GLC(gl, gl->WaitAsyncTexImage2DCHROMIUM(GL_TEXTURE_2D));
-    GLC(gl, gl->BindTexture(GL_TEXTURE_2D, 0));
+    gl->BindTexture(GL_TEXTURE_2D, resource->gl_id);
+    gl->WaitAsyncTexImage2DCHROMIUM(GL_TEXTURE_2D);
+    gl->BindTexture(GL_TEXTURE_2D, 0);
   }
 
   resource->set_pixels_completion_forced = true;
 }
 
 bool ResourceProvider::DidSetPixelsComplete(ResourceId id) {
   TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("cc.debug"),
                "ResourceProvider::DidSetPixelsComplete");
 
   Resource* resource = GetResource(id);
@@ skipping 42 matching lines @@
 
   DCHECK(resource->texture_pool);
   DCHECK(resource->origin == Resource::INTERNAL);
   DCHECK(!resource->mailbox.IsValid());
   resource->gl_id = texture_id_allocator_->NextId();
 
   GLES2Interface* gl = ContextGL();
   DCHECK(gl);
 
   // Create and set texture properties. Allocation is delayed until needed.
-  GLC(gl, gl->BindTexture(resource->target, resource->gl_id));
-  GLC(gl,
-      gl->TexParameteri(
-          resource->target, GL_TEXTURE_MIN_FILTER, resource->original_filter));
-  GLC(gl,
-      gl->TexParameteri(
-          resource->target, GL_TEXTURE_MAG_FILTER, resource->original_filter));
-  GLC(gl,
-      gl->TexParameteri(
-          resource->target, GL_TEXTURE_WRAP_S, resource->wrap_mode));
-  GLC(gl,
-      gl->TexParameteri(
-          resource->target, GL_TEXTURE_WRAP_T, resource->wrap_mode));
-  GLC(gl,
-      gl->TexParameteri(
-          resource->target, GL_TEXTURE_POOL_CHROMIUM, resource->texture_pool));
+  gl->BindTexture(resource->target, resource->gl_id);
+  gl->TexParameteri(resource->target, GL_TEXTURE_MIN_FILTER,
+                    resource->original_filter);
+  gl->TexParameteri(resource->target, GL_TEXTURE_MAG_FILTER,
+                    resource->original_filter);
+  gl->TexParameteri(resource->target, GL_TEXTURE_WRAP_S, resource->wrap_mode);
+  gl->TexParameteri(resource->target, GL_TEXTURE_WRAP_T, resource->wrap_mode);
+  gl->TexParameteri(resource->target, GL_TEXTURE_POOL_CHROMIUM,
+                    resource->texture_pool);
   if (use_texture_usage_hint_ && (resource->hint & TEXTURE_HINT_FRAMEBUFFER)) {
-    GLC(gl,
-        gl->TexParameteri(resource->target,
-                          GL_TEXTURE_USAGE_ANGLE,
-                          GL_FRAMEBUFFER_ATTACHMENT_ANGLE));
+    gl->TexParameteri(resource->target, GL_TEXTURE_USAGE_ANGLE,
+                      GL_FRAMEBUFFER_ATTACHMENT_ANGLE);
   }
 }
 
 void ResourceProvider::AllocateForTesting(ResourceId id) {
   LazyAllocate(GetResource(id));
 }
 
 void ResourceProvider::LazyAllocate(Resource* resource) {
   DCHECK(resource);
   if (resource->allocated)
     return;
   LazyCreate(resource);
   if (!resource->gl_id)
     return;
   resource->allocated = true;
   GLES2Interface* gl = ContextGL();
   gfx::Size& size = resource->size;
   DCHECK_EQ(resource->target, static_cast<GLenum>(GL_TEXTURE_2D));
   ResourceFormat format = resource->format;
-  GLC(gl, gl->BindTexture(GL_TEXTURE_2D, resource->gl_id));
+  gl->BindTexture(GL_TEXTURE_2D, resource->gl_id);
   if (use_texture_storage_ext_ &&
       IsFormatSupportedForStorage(format, use_texture_format_bgra_) &&
       (resource->hint & TEXTURE_HINT_IMMUTABLE)) {
     GLenum storage_format = TextureToStorageFormat(format);
-    GLC(gl,
-        gl->TexStorage2DEXT(
-            GL_TEXTURE_2D, 1, storage_format, size.width(), size.height()));
+    gl->TexStorage2DEXT(GL_TEXTURE_2D, 1, storage_format, size.width(),
+                        size.height());
   } else {
     // ETC1 does not support preallocation.
     if (format != ETC1) {
-      GLC(gl,
-          gl->TexImage2D(GL_TEXTURE_2D,
-                         0,
-                         GLInternalFormat(format),
-                         size.width(),
-                         size.height(),
-                         0,
-                         GLDataFormat(format),
-                         GLDataType(format),
-                         NULL));
+      gl->TexImage2D(GL_TEXTURE_2D, 0, GLInternalFormat(format), size.width(),
+                     size.height(), 0, GLDataFormat(format), GLDataType(format),
+                     NULL);
     }
   }
 }
 
 void ResourceProvider::BindImageForSampling(Resource* resource) {
   GLES2Interface* gl = ContextGL();
   DCHECK(resource->gl_id);
   DCHECK(resource->image_id);
 
   // Release image currently bound to texture.
@@ skipping 77 matching lines @@
   Resource* resource = GetResource(id);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(resource->allocated);
   if (resource->type != RESOURCE_TYPE_GL_TEXTURE || resource->gl_id)
     return;
   if (!resource->mailbox.sync_point())
     return;
   DCHECK(resource->mailbox.IsValid());
   GLES2Interface* gl = ContextGL();
   DCHECK(gl);
-  GLC(gl, gl->WaitSyncPointCHROMIUM(resource->mailbox.sync_point()));
+  gl->WaitSyncPointCHROMIUM(resource->mailbox.sync_point());
   resource->mailbox.set_sync_point(0);
 }
 
 void ResourceProvider::WaitReadLockIfNeeded(ResourceId id) {
   Resource* resource = GetResource(id);
   DCHECK_EQ(resource->exported_count, 0);
   if (!resource->read_lock_fence.get())
     return;
 
   resource->read_lock_fence->Wait();
@@ skipping 11 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