Rename WebKit namespace to blink (part 5)

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 WebKit { class WebGraphicsContext3D; }
+namespace blink { class WebGraphicsContext3D; }
 
 namespace gfx {
 class Rect;
 class Vector2d;
 }
 
 namespace cc {
 class IdAllocator;
 class SharedBitmap;
 class SharedBitmapManager;
@@ skipping 300 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(WebKit::WebGraphicsContext3D* context);
+  static GLint GetActiveTextureUnit(blink::WebGraphicsContext3D* context);
 
  private:
   struct Resource {
     Resource();
     ~Resource();
     Resource(unsigned texture_id,
              gfx::Size size,
              GLenum target,
              GLenum filter,
              GLenum texture_pool,
@@ skipping 74 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(WebKit::WebGraphicsContext3D* context,
+  void TransferResource(blink::WebGraphicsContext3D* context,
                         ResourceId id,
                         TransferableResource* resource);
   enum DeleteStyle {
     Normal,
     ForShutdown,
   };
   void DeleteResourceInternal(ResourceMap::iterator it, DeleteStyle style);
   void DeleteAndReturnUnusedResourcesToChild(Child* child_info,
                                              DeleteStyle style,
                                              const ResourceIdArray& unused);
   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. The resource
   // must be locked for reading.
   void BindForSampling(ResourceProvider::ResourceId resource_id,
                        GLenum target,
                        GLenum unit,
                        GLenum filter);
 
   // Returns NULL if the output_surface_ does not have a ContextProvider.
-  WebKit::WebGraphicsContext3D* Context3d() const;
+  blink::WebGraphicsContext3D* Context3d() 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 60 matching lines @@
   return format_gl_data_format[format];
 }
 
 inline GLenum GLInternalFormat(ResourceFormat format) {
   return GLDataFormat(format);
 }
 
 }  // namespace cc
 
 #endif  // CC_RESOURCES_RESOURCE_PROVIDER_H_