Implement shareResources==true in TestWebGraphicsContext3D

cc/test/test_web_graphics_context_3d.h

 // Copyright 2011 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_TEST_TEST_WEB_GRAPHICS_CONTEXT_3D_H_
 #define CC_TEST_TEST_WEB_GRAPHICS_CONTEXT_3D_H_
 
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/stl_util.h"
+#include "base/synchronization/lock.h"
 #include "cc/base/scoped_ptr_hash_map.h"
 #include "cc/debug/fake_web_graphics_context_3d.h"
 #include "third_party/khronos/GLES2/gl2.h"
 
 namespace WebKit { struct WebGraphicsMemoryAllocation; }
 
 namespace cc {
 
 class TestWebGraphicsContext3D : public FakeWebGraphicsContext3D {
  public:
   static scoped_ptr<TestWebGraphicsContext3D> Create() {
     return make_scoped_ptr(new TestWebGraphicsContext3D());
   }
   static scoped_ptr<TestWebGraphicsContext3D> Create(
       const WebKit::WebGraphicsContext3D::Attributes& attributes) {
     return make_scoped_ptr(new TestWebGraphicsContext3D(attributes));
   }
+  static scoped_ptr<TestWebGraphicsContext3D> CreateShared() {
+    WebKit::WebGraphicsContext3D::Attributes attrs;
+    attrs.shareResources = true;

[danakj, 2013/07/15 23:15:41]

this defaults true, right? so won't Create() also be shared?

[piman, 2013/07/16 00:45:33]

Done.

+    return Create(attrs);
+  }
   virtual ~TestWebGraphicsContext3D();
 
   virtual bool makeContextCurrent();
 
   virtual int width();
   virtual int height();
 
   virtual void reshapeWithScaleFactor(
       int width, int height, float scale_factor);
 
@@ skipping 119 matching lines @@
 
   // When set, mapImageCHROMIUM and mapBufferCHROMIUM will return NULL after
   // this many times.
   void set_times_map_image_chromium_succeeds(int times) {
     times_map_image_chromium_succeeds_ = times;
   }
   void set_times_map_buffer_chromium_succeeds(int times) {
     times_map_buffer_chromium_succeeds_ = times;
   }
 
-  size_t NumTextures() const { return textures_.size(); }
-  WebKit::WebGLId TextureAt(int i) const { return textures_[i]; }
+  size_t NumTextures() const;
+  WebKit::WebGLId TextureAt(int i) const;
 
   size_t NumUsedTextures() const { return used_textures_.size(); }
   bool UsedTexture(int texture) const {
     return ContainsKey(used_textures_, texture);
   }
   void ResetUsedTextures() { used_textures_.clear(); }
 
   void set_support_swapbuffers_complete_callback(bool support) {
     support_swapbuffers_complete_callback_ = support;
   }
@@ skipping 14 matching lines @@
   static const WebKit::WebGLId kExternalTextureId;
   virtual WebKit::WebGLId NextTextureId();
 
   virtual WebKit::WebGLId NextBufferId();
 
   virtual WebKit::WebGLId NextImageId();
 
   void SetMemoryAllocation(WebKit::WebGraphicsMemoryAllocation allocation);
 
  protected:
+  struct Buffer {
+    Buffer();
+    ~Buffer();
+
+    WebKit::WGC3Denum target;
+    scoped_ptr<uint8[]> pixels;
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(Buffer);
+  };
+
+  struct Image {
+    Image();
+    ~Image();
+
+    scoped_ptr<uint8[]> pixels;
+
+   private:
+    DISALLOW_COPY_AND_ASSIGN(Image);
+  };
+
+  struct Namespace : public base::RefCountedThreadSafe<Namespace> {
+    Namespace();
+
+    // Protects all fields;
+    base::Lock lock;
+    unsigned next_buffer_id;
+    unsigned next_image_id;
+    unsigned next_texture_id;
+    std::vector<WebKit::WebGLId> textures;
+    ScopedPtrHashMap<unsigned, Buffer> buffers;
+    ScopedPtrHashMap<unsigned, Image> images;
+
+   private:
+    friend class base::RefCountedThreadSafe<Namespace>;
+    ~Namespace();
+    DISALLOW_COPY_AND_ASSIGN(Namespace);
+  };
+
   TestWebGraphicsContext3D();
   TestWebGraphicsContext3D(
       const WebKit::WebGraphicsContext3D::Attributes& attributes);
 
   void CallAllSyncPointCallbacks();
   void SwapBuffersComplete();
 
   unsigned context_id_;
-  unsigned next_buffer_id_;
-  unsigned next_image_id_;
-  unsigned next_texture_id_;
   Attributes attributes_;
   bool support_swapbuffers_complete_callback_;
   bool have_extension_io_surface_;
   bool have_extension_egl_image_;
   int times_make_current_succeeds_;
   int times_bind_texture_succeeds_;
   int times_end_query_succeeds_;
   bool context_lost_;
   int times_map_image_chromium_succeeds_;
   int times_map_buffer_chromium_succeeds_;
   WebGraphicsContextLostCallback* context_lost_callback_;
   WebGraphicsSwapBuffersCompleteCallbackCHROMIUM* swap_buffers_callback_;
   WebGraphicsMemoryAllocationChangedCallbackCHROMIUM*
       memory_allocation_changed_callback_;
   std::vector<WebGraphicsSyncPointCallback*> sync_point_callbacks_;
-  std::vector<WebKit::WebGLId> textures_;
   base::hash_set<WebKit::WebGLId> used_textures_;
   std::vector<WebKit::WebGraphicsContext3D*> shared_contexts_;
   int max_texture_size_;
   int width_;
   int height_;
 
-  struct Buffer {
-    Buffer();
-    ~Buffer();
+  unsigned bound_buffer_;
 
-    WebKit::WGC3Denum target;
-    scoped_ptr<uint8[]> pixels;
+  scoped_refptr<Namespace> namespace_;
+  static Namespace* shared_namespace_;
 
-   private:
-    DISALLOW_COPY_AND_ASSIGN(Buffer);
-  };
-  ScopedPtrHashMap<unsigned, Buffer> buffers_;
-  unsigned bound_buffer_;
-  struct Image {
-    Image();
-    ~Image();
-
-    scoped_ptr<uint8[]> pixels;
-
-   private:
-    DISALLOW_COPY_AND_ASSIGN(Image);
-  };
-  ScopedPtrHashMap<unsigned, Image> images_;
   base::WeakPtrFactory<TestWebGraphicsContext3D> weak_ptr_factory_;
 };
 
 }  // namespace cc
 
 #endif  // CC_TEST_TEST_WEB_GRAPHICS_CONTEXT_3D_H_