Convert cc resource system over to GLES2Interface

cc/resources/resource_provider.h

 // 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.
 
 #ifndef CC_RESOURCES_RESOURCE_PROVIDER_H_
 #define CC_RESOURCES_RESOURCE_PROVIDER_H_
 
 #include <deque>
 #include <set>
 #include <string>
@@ skipping 13 matching lines @@
 #include "cc/resources/return_callback.h"
 #include "cc/resources/single_release_callback.h"
 #include "cc/resources/texture_mailbox.h"
 #include "cc/resources/transferable_resource.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/gfx/size.h"
 
-namespace blink { class WebGraphicsContext3D; }
+namespace gpu {
+namespace gles {
+class GLES2Interface;
+}
+}
 
 namespace gfx {
 class Rect;
 class Vector2d;
 }
 
 namespace cc {
 class IdAllocator;
 class SharedBitmap;
 class SharedBitmapManager;
@@ skipping 303 matching lines @@
     current_read_lock_fence_ = fence;
   }
   Fence* GetReadLockFence() { return current_read_lock_fence_.get(); }
 
   // Enable read lock fences for a specific resource.
   void EnableReadLockFences(ResourceProvider::ResourceId id, bool enable);
 
   // Indicates if we can currently lock this resource for write.
   bool CanLockForWrite(ResourceId id);
 
-  static GLint GetActiveTextureUnit(blink::WebGraphicsContext3D* context);
+  static GLint GetActiveTextureUnit(gpu::gles2::GLES2Interface* gl);
 
  private:
   struct Resource {
     Resource();
     ~Resource();
     Resource(unsigned texture_id,
              gfx::Size size,
              GLenum target,
              GLenum filter,
              GLenum texture_pool,
@@ skipping 75 matching lines @@
   void CleanUpGLIfNeeded();
 
   Resource* GetResource(ResourceId id);
   const Resource* LockForRead(ResourceId id);
   void UnlockForRead(ResourceId id);
   const Resource* LockForWrite(ResourceId id);
   void UnlockForWrite(ResourceId id);
   static void PopulateSkBitmapWithResource(SkBitmap* sk_bitmap,
                                            const Resource* resource);
 
-  void TransferResource(blink::WebGraphicsContext3D* context,
+  void TransferResource(gpu::gles2::GLES2Interface* gl,
                         ResourceId id,
                         TransferableResource* resource);
   enum DeleteStyle {
     Normal,
     ForShutdown,
   };
   void DeleteResourceInternal(ResourceMap::iterator it, DeleteStyle style);
   void DeleteAndReturnUnusedResourcesToChild(ChildMap::iterator child_it,
                                              DeleteStyle style,
                                              const ResourceIdArray& unused);
   void DestroyChildInternal(ChildMap::iterator it, DeleteStyle style);
   void LazyCreate(Resource* resource);
   void LazyAllocate(Resource* resource);
 
   // Binds the given GL resource to a texture target for sampling using the
   // specified filter for both minification and magnification. Returns the
   // texture target used. The resource must be locked for reading.
   GLenum BindForSampling(ResourceProvider::ResourceId resource_id,
                          GLenum unit,
                          GLenum filter);
 
   // Returns NULL if the output_surface_ does not have a ContextProvider.
-  blink::WebGraphicsContext3D* Context3d() const;
+  gpu::gles2::GLES2Interface* ContextGL() const;
 
   OutputSurface* output_surface_;
   SharedBitmapManager* shared_bitmap_manager_;
   bool lost_output_surface_;
   int highp_threshold_min_;
   ResourceId next_id_;
   ResourceMap resources_;
   int next_child_;
   ChildMap children_;
 
@@ skipping 59 matching lines @@
   return format_gl_data_format[format];
 }
 
 inline GLenum GLInternalFormat(ResourceFormat format) {
   return GLDataFormat(format);
 }
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_RESOURCE_PROVIDER_H_