src/cc/resources/resource_provider_unittest.cc

   1 // Copyright 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "cc/resources/resource_provider.h"
   6
   7 #include <algorithm>
   8 #include <map>
   9 #include <set>
  10
  11 #include "base/bind.h"
  12 #include "base/containers/hash_tables.h"
  13 #include "base/logging.h"
  14 #include "base/memory/ref_counted.h"
  15 #include "cc/base/scoped_ptr_deque.h"
  16 #include "cc/output/output_surface.h"
  17 #include "cc/resources/returned_resource.h"
  18 #include "cc/resources/shared_bitmap_manager.h"
  19 #include "cc/resources/single_release_callback.h"
  20 #include "cc/test/fake_output_surface.h"
  21 #include "cc/test/fake_output_surface_client.h"
  22 #include "cc/test/test_shared_bitmap_manager.h"
  23 #include "cc/test/test_texture.h"
  24 #include "cc/test/test_web_graphics_context_3d.h"
  25 #include "cc/trees/blocking_task_runner.h"
  26 #include "gpu/GLES2/gl2extchromium.h"
  27 #include "testing/gmock/include/gmock/gmock.h"
  28 #include "testing/gtest/include/gtest/gtest.h"
  29 #include "third_party/khronos/GLES2/gl2.h"
  30 #include "third_party/khronos/GLES2/gl2ext.h"
  31 #include "ui/gfx/rect.h"
  32
  33 using testing::Mock;
  34 using testing::NiceMock;
  35 using testing::Return;
  36 using testing::SetArgPointee;
  37 using testing::StrictMock;
  38 using testing::_;
  39
  40 namespace cc {
  41 namespace {
  42
  43 static void EmptyReleaseCallback(uint32 sync_point,
  44                                  bool lost_resource,
  45                                  BlockingTaskRunner* main_thread_task_runner) {
  46 }
  47
  48 static void ReleaseCallback(
  49     uint32* release_sync_point,
  50     bool* release_lost_resource,
  51     BlockingTaskRunner** release_main_thread_task_runner,
  52     uint32 sync_point,
  53     bool lost_resource,
  54     BlockingTaskRunner* main_thread_task_runner) {
  55   *release_sync_point = sync_point;
  56   *release_lost_resource = lost_resource;
  57   *release_main_thread_task_runner = main_thread_task_runner;
  58 }
  59
  60 static void SharedMemoryReleaseCallback(
  61     scoped_ptr<base::SharedMemory> memory,
  62     uint32 sync_point,
  63     bool lost_resource,
  64     BlockingTaskRunner* main_thread_task_runner) {
  65 }
  66
  67 static void ReleaseSharedMemoryCallback(
  68     scoped_ptr<base::SharedMemory> shared_memory,
  69     bool* release_called,
  70     uint32* release_sync_point,
  71     bool* lost_resource_result,
  72     uint32 sync_point,
  73     bool lost_resource,
  74     BlockingTaskRunner* main_thread_task_runner) {
  75   *release_called = true;
  76   *release_sync_point = sync_point;
  77   *lost_resource_result = lost_resource;
  78 }
  79
  80 static scoped_ptr<base::SharedMemory> CreateAndFillSharedMemory(
  81     const gfx::Size& size,
  82     uint32_t value) {
  83   scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory);
  84   CHECK(shared_memory->CreateAndMapAnonymous(4 * size.GetArea()));
  85   uint32_t* pixels = reinterpret_cast<uint32_t*>(shared_memory->memory());
  86   CHECK(pixels);
  87   std::fill_n(pixels, size.GetArea(), value);
  88   return shared_memory.Pass();
  89 }
  90
  91 class TextureStateTrackingContext : public TestWebGraphicsContext3D {
  92  public:
  93   MOCK_METHOD2(bindTexture, void(GLenum target, GLuint texture));
  94   MOCK_METHOD3(texParameteri, void(GLenum target, GLenum pname, GLint param));
  95   MOCK_METHOD1(waitSyncPoint, void(GLuint sync_point));
  96   MOCK_METHOD0(insertSyncPoint, GLuint(void));
  97   MOCK_METHOD2(produceTextureCHROMIUM,
  98                void(GLenum target, const GLbyte* mailbox));
  99   MOCK_METHOD2(consumeTextureCHROMIUM,
 100                void(GLenum target, const GLbyte* mailbox));
 101
 102   // Force all textures to be consecutive numbers starting at "1",
 103   // so we easily can test for them.
 104   virtual GLuint NextTextureId() OVERRIDE {
 105     base::AutoLock lock(namespace_->lock);
 106     return namespace_->next_texture_id++;
 107   }
 108   virtual void RetireTextureId(GLuint) OVERRIDE {}
 109 };
 110
 111 // Shared data between multiple ResourceProviderContext. This contains mailbox
 112 // contents as well as information about sync points.
 113 class ContextSharedData {
 114  public:
 115   static scoped_ptr<ContextSharedData> Create() {
 116     return make_scoped_ptr(new ContextSharedData());
 117   }
 118
 119   uint32 InsertSyncPoint() { return next_sync_point_++; }
 120
 121   void GenMailbox(GLbyte* mailbox) {
 122     memset(mailbox, 0, GL_MAILBOX_SIZE_CHROMIUM);
 123     memcpy(mailbox, &next_mailbox_, sizeof(next_mailbox_));
 124     ++next_mailbox_;
 125   }
 126
 127   void ProduceTexture(const GLbyte* mailbox_name,
 128                       uint32 sync_point,
 129                       scoped_refptr<TestTexture> texture) {
 130     unsigned mailbox = 0;
 131     memcpy(&mailbox, mailbox_name, sizeof(mailbox));
 132     ASSERT_TRUE(mailbox && mailbox < next_mailbox_);
 133     textures_[mailbox] = texture;
 134     ASSERT_LT(sync_point_for_mailbox_[mailbox], sync_point);
 135     sync_point_for_mailbox_[mailbox] = sync_point;
 136   }
 137
 138   scoped_refptr<TestTexture> ConsumeTexture(const GLbyte* mailbox_name,
 139                                             uint32 sync_point) {
 140     unsigned mailbox = 0;
 141     memcpy(&mailbox, mailbox_name, sizeof(mailbox));
 142     DCHECK(mailbox && mailbox < next_mailbox_);
 143
 144     // If the latest sync point the context has waited on is before the sync
 145     // point for when the mailbox was set, pretend we never saw that
 146     // ProduceTexture.
 147     if (sync_point_for_mailbox_[mailbox] > sync_point) {
 148       NOTREACHED();
 149       return scoped_refptr<TestTexture>();
 150     }
 151     return textures_[mailbox];
 152   }
 153
 154  private:
 155   ContextSharedData() : next_sync_point_(1), next_mailbox_(1) {}
 156
 157   uint32 next_sync_point_;
 158   unsigned next_mailbox_;
 159   typedef base::hash_map<unsigned, scoped_refptr<TestTexture> > TextureMap;
 160   TextureMap textures_;
 161   base::hash_map<unsigned, uint32> sync_point_for_mailbox_;
 162 };
 163
 164 class ResourceProviderContext : public TestWebGraphicsContext3D {
 165  public:
 166   static scoped_ptr<ResourceProviderContext> Create(
 167       ContextSharedData* shared_data) {
 168     return make_scoped_ptr(new ResourceProviderContext(shared_data));
 169   }
 170
 171   virtual GLuint insertSyncPoint() OVERRIDE {
 172     uint32 sync_point = shared_data_->InsertSyncPoint();
 173     // Commit the produceTextureCHROMIUM calls at this point, so that
 174     // they're associated with the sync point.
 175     for (PendingProduceTextureList::iterator it =
 176              pending_produce_textures_.begin();
 177          it != pending_produce_textures_.end();
 178          ++it) {
 179       shared_data_->ProduceTexture(
 180           (*it)->mailbox, sync_point, (*it)->texture);
 181     }
 182     pending_produce_textures_.clear();
 183     return sync_point;
 184   }
 185
 186   virtual void waitSyncPoint(GLuint sync_point) OVERRIDE {
 187     last_waited_sync_point_ = std::max(sync_point, last_waited_sync_point_);
 188   }
 189
 190   unsigned last_waited_sync_point() const { return last_waited_sync_point_; }
 191
 192   virtual void texStorage2DEXT(GLenum target,
 193                                GLint levels,
 194                                GLuint internalformat,
 195                                GLint width,
 196                                GLint height) OVERRIDE {
 197     CheckTextureIsBound(target);
 198     ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
 199     ASSERT_EQ(1, levels);
 200     GLenum format = GL_RGBA;
 201     switch (internalformat) {
 202       case GL_RGBA8_OES:
 203         break;
 204       case GL_BGRA8_EXT:
 205         format = GL_BGRA_EXT;
 206         break;
 207       default:
 208         NOTREACHED();
 209     }
 210     AllocateTexture(gfx::Size(width, height), format);
 211   }
 212
 213   virtual void texImage2D(GLenum target,
 214                           GLint level,
 215                           GLenum internalformat,
 216                           GLsizei width,
 217                           GLsizei height,
 218                           GLint border,
 219                           GLenum format,
 220                           GLenum type,
 221                           const void* pixels) OVERRIDE {
 222     CheckTextureIsBound(target);
 223     ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
 224     ASSERT_FALSE(level);
 225     ASSERT_EQ(internalformat, format);
 226     ASSERT_FALSE(border);
 227     ASSERT_EQ(static_cast<unsigned>(GL_UNSIGNED_BYTE), type);
 228     AllocateTexture(gfx::Size(width, height), format);
 229     if (pixels)
 230       SetPixels(0, 0, width, height, pixels);
 231   }
 232
 233   virtual void texSubImage2D(GLenum target,
 234                              GLint level,
 235                              GLint xoffset,
 236                              GLint yoffset,
 237                              GLsizei width,
 238                              GLsizei height,
 239                              GLenum format,
 240                              GLenum type,
 241                              const void* pixels) OVERRIDE {
 242     CheckTextureIsBound(target);
 243     ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
 244     ASSERT_FALSE(level);
 245     ASSERT_EQ(static_cast<unsigned>(GL_UNSIGNED_BYTE), type);
 246     {
 247       base::AutoLock lock_for_texture_access(namespace_->lock);
 248       ASSERT_EQ(GLDataFormat(BoundTexture(target)->format), format);
 249     }
 250     ASSERT_TRUE(pixels);
 251     SetPixels(xoffset, yoffset, width, height, pixels);
 252   }
 253
 254   virtual void genMailboxCHROMIUM(GLbyte* mailbox) OVERRIDE {
 255     return shared_data_->GenMailbox(mailbox);
 256   }
 257
 258   virtual void produceTextureCHROMIUM(GLenum target,
 259                                       const GLbyte* mailbox) OVERRIDE {
 260     CheckTextureIsBound(target);
 261
 262     // Delay moving the texture into the mailbox until the next
 263     // InsertSyncPoint, so that it is not visible to other contexts that
 264     // haven't waited on that sync point.
 265     scoped_ptr<PendingProduceTexture> pending(new PendingProduceTexture);
 266     memcpy(pending->mailbox, mailbox, sizeof(pending->mailbox));
 267     base::AutoLock lock_for_texture_access(namespace_->lock);
 268     pending->texture = BoundTexture(target);
 269     pending_produce_textures_.push_back(pending.Pass());
 270   }
 271
 272   virtual void consumeTextureCHROMIUM(GLenum target,
 273                                       const GLbyte* mailbox) OVERRIDE {
 274     CheckTextureIsBound(target);
 275     base::AutoLock lock_for_texture_access(namespace_->lock);
 276     scoped_refptr<TestTexture> texture =
 277         shared_data_->ConsumeTexture(mailbox, last_waited_sync_point_);
 278     namespace_->textures.Replace(BoundTextureId(target), texture);
 279   }
 280
 281   void GetPixels(const gfx::Size& size,
 282                  ResourceFormat format,
 283                  uint8_t* pixels) {
 284     CheckTextureIsBound(GL_TEXTURE_2D);
 285     base::AutoLock lock_for_texture_access(namespace_->lock);
 286     scoped_refptr<TestTexture> texture = BoundTexture(GL_TEXTURE_2D);
 287     ASSERT_EQ(texture->size, size);
 288     ASSERT_EQ(texture->format, format);
 289     memcpy(pixels, texture->data.get(), TextureSizeBytes(size, format));
 290   }
 291
 292  protected:
 293   explicit ResourceProviderContext(ContextSharedData* shared_data)
 294       : shared_data_(shared_data),
 295         last_waited_sync_point_(0) {}
 296
 297  private:
 298   void AllocateTexture(const gfx::Size& size, GLenum format) {
 299     CheckTextureIsBound(GL_TEXTURE_2D);
 300     ResourceFormat texture_format = RGBA_8888;
 301     switch (format) {
 302       case GL_RGBA:
 303         texture_format = RGBA_8888;
 304         break;
 305       case GL_BGRA_EXT:
 306         texture_format = BGRA_8888;
 307         break;
 308     }
 309     base::AutoLock lock_for_texture_access(namespace_->lock);
 310     BoundTexture(GL_TEXTURE_2D)->Reallocate(size, texture_format);
 311   }
 312
 313   void SetPixels(int xoffset,
 314                  int yoffset,
 315                  int width,
 316                  int height,
 317                  const void* pixels) {
 318     CheckTextureIsBound(GL_TEXTURE_2D);
 319     base::AutoLock lock_for_texture_access(namespace_->lock);
 320     scoped_refptr<TestTexture> texture = BoundTexture(GL_TEXTURE_2D);
 321     ASSERT_TRUE(texture->data.get());
 322     ASSERT_TRUE(xoffset >= 0 && xoffset + width <= texture->size.width());
 323     ASSERT_TRUE(yoffset >= 0 && yoffset + height <= texture->size.height());
 324     ASSERT_TRUE(pixels);
 325     size_t in_pitch = TextureSizeBytes(gfx::Size(width, 1), texture->format);
 326     size_t out_pitch =
 327         TextureSizeBytes(gfx::Size(texture->size.width(), 1), texture->format);
 328     uint8_t* dest = texture->data.get() + yoffset * out_pitch +
 329                     TextureSizeBytes(gfx::Size(xoffset, 1), texture->format);
 330     const uint8_t* src = static_cast<const uint8_t*>(pixels);
 331     for (int i = 0; i < height; ++i) {
 332       memcpy(dest, src, in_pitch);
 333       dest += out_pitch;
 334       src += in_pitch;
 335     }
 336   }
 337
 338   struct PendingProduceTexture {
 339     GLbyte mailbox[GL_MAILBOX_SIZE_CHROMIUM];
 340     scoped_refptr<TestTexture> texture;
 341   };
 342   typedef ScopedPtrDeque<PendingProduceTexture> PendingProduceTextureList;
 343   ContextSharedData* shared_data_;
 344   GLuint last_waited_sync_point_;
 345   PendingProduceTextureList pending_produce_textures_;
 346 };
 347
 348 void GetResourcePixels(ResourceProvider* resource_provider,
 349                        ResourceProviderContext* context,
 350                        ResourceProvider::ResourceId id,
 351                        const gfx::Size& size,
 352                        ResourceFormat format,
 353                        uint8_t* pixels) {
 354   resource_provider->WaitSyncPointIfNeeded(id);
 355   switch (resource_provider->default_resource_type()) {
 356     case ResourceProvider::GLTexture: {
 357       ResourceProvider::ScopedReadLockGL lock_gl(resource_provider, id);
 358       ASSERT_NE(0U, lock_gl.texture_id());
 359       context->bindTexture(GL_TEXTURE_2D, lock_gl.texture_id());
 360       context->GetPixels(size, format, pixels);
 361       break;
 362     }
 363     case ResourceProvider::Bitmap: {
 364       ResourceProvider::ScopedReadLockSoftware lock_software(resource_provider,
 365                                                              id);
 366       memcpy(pixels,
 367              lock_software.sk_bitmap()->getPixels(),
 368              lock_software.sk_bitmap()->getSize());
 369       break;
 370     }
 371     case ResourceProvider::InvalidType:
 372       NOTREACHED();
 373       break;
 374   }
 375 }
 376
 377 class ResourceProviderTest
 378     : public testing::TestWithParam<ResourceProvider::ResourceType> {
 379  public:
 380   ResourceProviderTest()
 381       : shared_data_(ContextSharedData::Create()),
 382         context3d_(NULL),
 383         child_context_(NULL),
 384         main_thread_task_runner_(BlockingTaskRunner::Create(NULL)) {
 385     switch (GetParam()) {
 386       case ResourceProvider::GLTexture: {
 387         scoped_ptr<ResourceProviderContext> context3d(
 388             ResourceProviderContext::Create(shared_data_.get()));
 389         context3d_ = context3d.get();
 390
 391         scoped_refptr<TestContextProvider> context_provider =
 392             TestContextProvider::Create(
 393                 context3d.PassAs<TestWebGraphicsContext3D>());
 394
 395         output_surface_ = FakeOutputSurface::Create3d(context_provider);
 396
 397         scoped_ptr<ResourceProviderContext> child_context_owned =
 398             ResourceProviderContext::Create(shared_data_.get());
 399         child_context_ = child_context_owned.get();
 400         child_output_surface_ = FakeOutputSurface::Create3d(
 401             child_context_owned.PassAs<TestWebGraphicsContext3D>());
 402         break;
 403       }
 404       case ResourceProvider::Bitmap:
 405         output_surface_ = FakeOutputSurface::CreateSoftware(
 406             make_scoped_ptr(new SoftwareOutputDevice));
 407         child_output_surface_ = FakeOutputSurface::CreateSoftware(
 408             make_scoped_ptr(new SoftwareOutputDevice));
 409         break;
 410       case ResourceProvider::InvalidType:
 411         NOTREACHED();
 412         break;
 413     }
 414     CHECK(output_surface_->BindToClient(&output_surface_client_));
 415     CHECK(child_output_surface_->BindToClient(&child_output_surface_client_));
 416
 417     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
 418
 419     resource_provider_ =
 420         ResourceProvider::Create(output_surface_.get(),
 421                                  shared_bitmap_manager_.get(),
 422                                  main_thread_task_runner_.get(),
 423                                  0,
 424                                  false,
 425                                  1,
 426                                  false);
 427     child_resource_provider_ =
 428         ResourceProvider::Create(child_output_surface_.get(),
 429                                  shared_bitmap_manager_.get(),
 430                                  main_thread_task_runner_.get(),
 431                                  0,
 432                                  false,
 433                                  1,
 434                                  false);
 435   }
 436
 437   static void CollectResources(ReturnedResourceArray* array,
 438                                const ReturnedResourceArray& returned,
 439                                BlockingTaskRunner* main_thread_task_runner) {
 440     array->insert(array->end(), returned.begin(), returned.end());
 441   }
 442
 443   static ReturnCallback GetReturnCallback(ReturnedResourceArray* array) {
 444     return base::Bind(&ResourceProviderTest::CollectResources, array);
 445   }
 446
 447   static void SetResourceFilter(ResourceProvider* resource_provider,
 448                                 ResourceProvider::ResourceId id,
 449                                 GLenum filter) {
 450     ResourceProvider::ScopedSamplerGL sampler(
 451         resource_provider, id, GL_TEXTURE_2D, filter);
 452   }
 453
 454   ResourceProviderContext* context() { return context3d_; }
 455
 456   ResourceProvider::ResourceId CreateChildMailbox(uint32* release_sync_point,
 457                                                   bool* lost_resource,
 458                                                   bool* release_called,
 459                                                   uint32* sync_point) {
 460     if (GetParam() == ResourceProvider::GLTexture) {
 461       unsigned texture = child_context_->createTexture();
 462       gpu::Mailbox gpu_mailbox;
 463       child_context_->bindTexture(GL_TEXTURE_2D, texture);
 464       child_context_->genMailboxCHROMIUM(gpu_mailbox.name);
 465       child_context_->produceTextureCHROMIUM(GL_TEXTURE_2D, gpu_mailbox.name);
 466       *sync_point = child_context_->insertSyncPoint();
 467       EXPECT_LT(0u, *sync_point);
 468
 469       scoped_ptr<base::SharedMemory> shared_memory;
 470       scoped_ptr<SingleReleaseCallbackImpl> callback =
 471           SingleReleaseCallbackImpl::Create(
 472               base::Bind(ReleaseSharedMemoryCallback,
 473                          base::Passed(&shared_memory),
 474                          release_called,
 475                          release_sync_point,
 476                          lost_resource));
 477       return child_resource_provider_->CreateResourceFromTextureMailbox(
 478           TextureMailbox(gpu_mailbox, GL_TEXTURE_2D, *sync_point),
 479           callback.Pass());
 480     } else {
 481       gfx::Size size(64, 64);
 482       scoped_ptr<base::SharedMemory> shared_memory(
 483           CreateAndFillSharedMemory(size, 0));
 484
 485       base::SharedMemory* shared_memory_ptr = shared_memory.get();
 486       scoped_ptr<SingleReleaseCallbackImpl> callback =
 487           SingleReleaseCallbackImpl::Create(
 488               base::Bind(ReleaseSharedMemoryCallback,
 489                          base::Passed(&shared_memory),
 490                          release_called,
 491                          release_sync_point,
 492                          lost_resource));
 493       return child_resource_provider_->CreateResourceFromTextureMailbox(
 494           TextureMailbox(shared_memory_ptr, size), callback.Pass());
 495     }
 496   }
 497
 498  protected:
 499   scoped_ptr<ContextSharedData> shared_data_;
 500   ResourceProviderContext* context3d_;
 501   ResourceProviderContext* child_context_;
 502   FakeOutputSurfaceClient output_surface_client_;
 503   FakeOutputSurfaceClient child_output_surface_client_;
 504   scoped_ptr<OutputSurface> output_surface_;
 505   scoped_ptr<OutputSurface> child_output_surface_;
 506   scoped_ptr<BlockingTaskRunner> main_thread_task_runner_;
 507   scoped_ptr<ResourceProvider> resource_provider_;
 508   scoped_ptr<ResourceProvider> child_resource_provider_;
 509   scoped_ptr<TestSharedBitmapManager> shared_bitmap_manager_;
 510 };
 511
 512 void CheckCreateResource(ResourceProvider::ResourceType expected_default_type,
 513                          ResourceProvider* resource_provider,
 514                          ResourceProviderContext* context) {
 515   DCHECK_EQ(expected_default_type, resource_provider->default_resource_type());
 516
 517   gfx::Size size(1, 1);
 518   ResourceFormat format = RGBA_8888;
 519   size_t pixel_size = TextureSizeBytes(size, format);
 520   ASSERT_EQ(4U, pixel_size);
 521
 522   ResourceProvider::ResourceId id = resource_provider->CreateResource(
 523       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
 524   EXPECT_EQ(1, static_cast<int>(resource_provider->num_resources()));
 525   if (expected_default_type == ResourceProvider::GLTexture)
 526     EXPECT_EQ(0u, context->NumTextures());
 527
 528   uint8_t data[4] = { 1, 2, 3, 4 };
 529   gfx::Rect rect(size);
 530   resource_provider->SetPixels(id, data, rect, rect, gfx::Vector2d());
 531   if (expected_default_type == ResourceProvider::GLTexture)
 532     EXPECT_EQ(1u, context->NumTextures());
 533
 534   uint8_t result[4] = { 0 };
 535   GetResourcePixels(resource_provider, context, id, size, format, result);
 536   EXPECT_EQ(0, memcmp(data, result, pixel_size));
 537
 538   resource_provider->DeleteResource(id);
 539   EXPECT_EQ(0, static_cast<int>(resource_provider->num_resources()));
 540   if (expected_default_type == ResourceProvider::GLTexture)
 541     EXPECT_EQ(0u, context->NumTextures());
 542 }
 543
 544 TEST_P(ResourceProviderTest, Basic) {
 545   CheckCreateResource(GetParam(), resource_provider_.get(), context());
 546 }
 547
 548 TEST_P(ResourceProviderTest, Upload) {
 549   gfx::Size size(2, 2);
 550   ResourceFormat format = RGBA_8888;
 551   size_t pixel_size = TextureSizeBytes(size, format);
 552   ASSERT_EQ(16U, pixel_size);
 553
 554   ResourceProvider::ResourceId id = resource_provider_->CreateResource(
 555       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
 556
 557   uint8_t image[16] = { 0 };
 558   gfx::Rect image_rect(size);
 559   resource_provider_->SetPixels(
 560       id, image, image_rect, image_rect, gfx::Vector2d());
 561
 562   for (uint8_t i = 0; i < pixel_size; ++i)
 563     image[i] = i;
 564
 565   uint8_t result[16] = { 0 };
 566   {
 567     gfx::Rect source_rect(0, 0, 1, 1);
 568     gfx::Vector2d dest_offset(0, 0);
 569     resource_provider_->SetPixels(
 570         id, image, image_rect, source_rect, dest_offset);
 571
 572     uint8_t expected[16] = { 0, 1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 573     GetResourcePixels(
 574         resource_provider_.get(), context(), id, size, format, result);
 575     EXPECT_EQ(0, memcmp(expected, result, pixel_size));
 576   }
 577   {
 578     gfx::Rect source_rect(0, 0, 1, 1);
 579     gfx::Vector2d dest_offset(1, 1);
 580     resource_provider_->SetPixels(
 581         id, image, image_rect, source_rect, dest_offset);
 582
 583     uint8_t expected[16] = { 0, 1, 2, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3 };
 584     GetResourcePixels(
 585         resource_provider_.get(), context(), id, size, format, result);
 586     EXPECT_EQ(0, memcmp(expected, result, pixel_size));
 587   }
 588   {
 589     gfx::Rect source_rect(1, 0, 1, 1);
 590     gfx::Vector2d dest_offset(0, 1);
 591     resource_provider_->SetPixels(
 592         id, image, image_rect, source_rect, dest_offset);
 593
 594     uint8_t expected[16] = { 0, 1, 2, 3, 0, 0, 0, 0, 4, 5, 6, 7, 0, 1, 2, 3 };
 595     GetResourcePixels(
 596         resource_provider_.get(), context(), id, size, format, result);
 597     EXPECT_EQ(0, memcmp(expected, result, pixel_size));
 598   }
 599   {
 600     gfx::Rect offset_image_rect(gfx::Point(100, 100), size);
 601     gfx::Rect source_rect(100, 100, 1, 1);
 602     gfx::Vector2d dest_offset(1, 0);
 603     resource_provider_->SetPixels(
 604         id, image, offset_image_rect, source_rect, dest_offset);
 605
 606     uint8_t expected[16] = { 0, 1, 2, 3, 0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3 };
 607     GetResourcePixels(
 608         resource_provider_.get(), context(), id, size, format, result);
 609     EXPECT_EQ(0, memcmp(expected, result, pixel_size));
 610   }
 611
 612   resource_provider_->DeleteResource(id);
 613 }
 614
 615 TEST_P(ResourceProviderTest, TransferGLResources) {
 616   if (GetParam() != ResourceProvider::GLTexture)
 617     return;
 618   gfx::Size size(1, 1);
 619   ResourceFormat format = RGBA_8888;
 620   size_t pixel_size = TextureSizeBytes(size, format);
 621   ASSERT_EQ(4U, pixel_size);
 622
 623   ResourceProvider::ResourceId id1 = child_resource_provider_->CreateResource(
 624       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
 625   uint8_t data1[4] = { 1, 2, 3, 4 };
 626   gfx::Rect rect(size);
 627   child_resource_provider_->SetPixels(id1, data1, rect, rect, gfx::Vector2d());
 628
 629   ResourceProvider::ResourceId id2 = child_resource_provider_->CreateResource(
 630       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
 631   uint8_t data2[4] = { 5, 5, 5, 5 };
 632   child_resource_provider_->SetPixels(id2, data2, rect, rect, gfx::Vector2d());
 633
 634   ResourceProvider::ResourceId id3 = child_resource_provider_->CreateResource(
 635       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
 636   child_resource_provider_->AcquireImage(id3);
 637   int stride;
 638   child_resource_provider_->MapImage(id3, &stride);
 639   child_resource_provider_->UnmapImage(id3);
 640
 641   GLuint external_texture_id = child_context_->createExternalTexture();
 642   child_context_->bindTexture(GL_TEXTURE_EXTERNAL_OES, external_texture_id);
 643
 644   gpu::Mailbox external_mailbox;
 645   child_context_->genMailboxCHROMIUM(external_mailbox.name);
 646   child_context_->produceTextureCHROMIUM(GL_TEXTURE_EXTERNAL_OES,
 647                                          external_mailbox.name);
 648   const GLuint external_sync_point = child_context_->insertSyncPoint();
 649   ResourceProvider::ResourceId id4 =
 650       child_resource_provider_->CreateResourceFromTextureMailbox(
 651           TextureMailbox(
 652               external_mailbox, GL_TEXTURE_EXTERNAL_OES, external_sync_point),
 653           SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback)));
 654
 655   ReturnedResourceArray returned_to_child;
 656   int child_id =
 657       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
 658   {
 659     // Transfer some resources to the parent.
 660     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
 661     resource_ids_to_transfer.push_back(id1);
 662     resource_ids_to_transfer.push_back(id2);
 663     resource_ids_to_transfer.push_back(id3);
 664     resource_ids_to_transfer.push_back(id4);
 665     TransferableResourceArray list;
 666     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
 667                                                   &list);
 668     ASSERT_EQ(4u, list.size());
 669     EXPECT_NE(0u, list[0].mailbox_holder.sync_point);
 670     EXPECT_NE(0u, list[1].mailbox_holder.sync_point);
 671     EXPECT_EQ(list[0].mailbox_holder.sync_point,
 672               list[1].mailbox_holder.sync_point);
 673     EXPECT_NE(0u, list[2].mailbox_holder.sync_point);
 674     EXPECT_EQ(list[0].mailbox_holder.sync_point,
 675               list[2].mailbox_holder.sync_point);
 676     EXPECT_EQ(external_sync_point, list[3].mailbox_holder.sync_point);
 677     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
 678               list[0].mailbox_holder.texture_target);
 679     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
 680               list[1].mailbox_holder.texture_target);
 681     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
 682               list[2].mailbox_holder.texture_target);
 683     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES),
 684               list[3].mailbox_holder.texture_target);
 685     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
 686     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id2));
 687     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id3));
 688     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id4));
 689     resource_provider_->ReceiveFromChild(child_id, list);
 690     EXPECT_NE(list[0].mailbox_holder.sync_point,
 691               context3d_->last_waited_sync_point());
 692     {
 693       resource_provider_->WaitSyncPointIfNeeded(list[0].id);
 694       ResourceProvider::ScopedReadLockGL lock(resource_provider_.get(),
 695                                               list[0].id);
 696     }
 697     EXPECT_EQ(list[0].mailbox_holder.sync_point,
 698               context3d_->last_waited_sync_point());
 699     resource_provider_->DeclareUsedResourcesFromChild(child_id,
 700                                                       resource_ids_to_transfer);
 701   }
 702
 703   EXPECT_EQ(4u, resource_provider_->num_resources());
 704   ResourceProvider::ResourceIdMap resource_map =
 705       resource_provider_->GetChildToParentMap(child_id);
 706   ResourceProvider::ResourceId mapped_id1 = resource_map[id1];
 707   ResourceProvider::ResourceId mapped_id2 = resource_map[id2];
 708   ResourceProvider::ResourceId mapped_id3 = resource_map[id3];
 709   ResourceProvider::ResourceId mapped_id4 = resource_map[id4];
 710   EXPECT_NE(0u, mapped_id1);
 711   EXPECT_NE(0u, mapped_id2);
 712   EXPECT_NE(0u, mapped_id3);
 713   EXPECT_NE(0u, mapped_id4);
 714   EXPECT_FALSE(resource_provider_->InUseByConsumer(id1));
 715   EXPECT_FALSE(resource_provider_->InUseByConsumer(id2));
 716   EXPECT_FALSE(resource_provider_->InUseByConsumer(id3));
 717   EXPECT_FALSE(resource_provider_->InUseByConsumer(id4));
 718
 719   uint8_t result[4] = { 0 };
 720   GetResourcePixels(
 721       resource_provider_.get(), context(), mapped_id1, size, format, result);
 722   EXPECT_EQ(0, memcmp(data1, result, pixel_size));
 723
 724   GetResourcePixels(
 725       resource_provider_.get(), context(), mapped_id2, size, format, result);
 726   EXPECT_EQ(0, memcmp(data2, result, pixel_size));
 727
 728   {
 729     // Check that transfering again the same resource from the child to the
 730     // parent works.
 731     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
 732     resource_ids_to_transfer.push_back(id1);
 733     resource_ids_to_transfer.push_back(id2);
 734     resource_ids_to_transfer.push_back(id3);
 735     TransferableResourceArray list;
 736     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
 737                                                   &list);
 738     EXPECT_EQ(3u, list.size());
 739     EXPECT_EQ(id1, list[0].id);
 740     EXPECT_EQ(id2, list[1].id);
 741     EXPECT_EQ(id3, list[2].id);
 742     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
 743               list[0].mailbox_holder.texture_target);
 744     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
 745               list[1].mailbox_holder.texture_target);
 746     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
 747               list[2].mailbox_holder.texture_target);
 748     ReturnedResourceArray returned;
 749     TransferableResource::ReturnResources(list, &returned);
 750     child_resource_provider_->ReceiveReturnsFromParent(returned);
 751     // ids were exported twice, we returned them only once, they should still
 752     // be in-use.
 753     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
 754     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id2));
 755     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id3));
 756   }
 757   {
 758     EXPECT_EQ(0u, returned_to_child.size());
 759
 760     // Transfer resources back from the parent to the child. Set no resources as
 761     // being in use.
 762     ResourceProvider::ResourceIdArray no_resources;
 763     resource_provider_->DeclareUsedResourcesFromChild(child_id, no_resources);
 764
 765     ASSERT_EQ(4u, returned_to_child.size());
 766     EXPECT_NE(0u, returned_to_child[0].sync_point);
 767     EXPECT_NE(0u, returned_to_child[1].sync_point);
 768     EXPECT_NE(0u, returned_to_child[2].sync_point);
 769     EXPECT_NE(0u, returned_to_child[3].sync_point);
 770     EXPECT_FALSE(returned_to_child[0].lost);
 771     EXPECT_FALSE(returned_to_child[1].lost);
 772     EXPECT_FALSE(returned_to_child[2].lost);
 773     EXPECT_FALSE(returned_to_child[3].lost);
 774     child_resource_provider_->ReceiveReturnsFromParent(returned_to_child);
 775     returned_to_child.clear();
 776   }
 777   EXPECT_FALSE(child_resource_provider_->InUseByConsumer(id1));
 778   EXPECT_FALSE(child_resource_provider_->InUseByConsumer(id2));
 779   EXPECT_FALSE(child_resource_provider_->InUseByConsumer(id3));
 780   EXPECT_FALSE(child_resource_provider_->InUseByConsumer(id4));
 781
 782   {
 783     child_resource_provider_->WaitSyncPointIfNeeded(id1);
 784     ResourceProvider::ScopedReadLockGL lock(child_resource_provider_.get(),
 785                                             id1);
 786     ASSERT_NE(0U, lock.texture_id());
 787     child_context_->bindTexture(GL_TEXTURE_2D, lock.texture_id());
 788     child_context_->GetPixels(size, format, result);
 789     EXPECT_EQ(0, memcmp(data1, result, pixel_size));
 790   }
 791   {
 792     child_resource_provider_->WaitSyncPointIfNeeded(id2);
 793     ResourceProvider::ScopedReadLockGL lock(child_resource_provider_.get(),
 794                                             id2);
 795     ASSERT_NE(0U, lock.texture_id());
 796     child_context_->bindTexture(GL_TEXTURE_2D, lock.texture_id());
 797     child_context_->GetPixels(size, format, result);
 798     EXPECT_EQ(0, memcmp(data2, result, pixel_size));
 799   }
 800   {
 801     child_resource_provider_->WaitSyncPointIfNeeded(id3);
 802     ResourceProvider::ScopedReadLockGL lock(child_resource_provider_.get(),
 803                                             id3);
 804     ASSERT_NE(0U, lock.texture_id());
 805     child_context_->bindTexture(GL_TEXTURE_2D, lock.texture_id());
 806   }
 807   {
 808     // Transfer resources to the parent again.
 809     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
 810     resource_ids_to_transfer.push_back(id1);
 811     resource_ids_to_transfer.push_back(id2);
 812     resource_ids_to_transfer.push_back(id3);
 813     resource_ids_to_transfer.push_back(id4);
 814     TransferableResourceArray list;
 815     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
 816                                                   &list);
 817     ASSERT_EQ(4u, list.size());
 818     EXPECT_EQ(id1, list[0].id);
 819     EXPECT_EQ(id2, list[1].id);
 820     EXPECT_EQ(id3, list[2].id);
 821     EXPECT_EQ(id4, list[3].id);
 822     EXPECT_NE(0u, list[0].mailbox_holder.sync_point);
 823     EXPECT_NE(0u, list[1].mailbox_holder.sync_point);
 824     EXPECT_NE(0u, list[2].mailbox_holder.sync_point);
 825     EXPECT_NE(0u, list[3].mailbox_holder.sync_point);
 826     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
 827               list[0].mailbox_holder.texture_target);
 828     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
 829               list[1].mailbox_holder.texture_target);
 830     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
 831               list[2].mailbox_holder.texture_target);
 832     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_EXTERNAL_OES),
 833               list[3].mailbox_holder.texture_target);
 834     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
 835     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id2));
 836     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id3));
 837     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id4));
 838     resource_provider_->ReceiveFromChild(child_id, list);
 839     resource_provider_->DeclareUsedResourcesFromChild(child_id,
 840                                                       resource_ids_to_transfer);
 841   }
 842
 843   EXPECT_EQ(0u, returned_to_child.size());
 844
 845   EXPECT_EQ(4u, resource_provider_->num_resources());
 846   resource_provider_->DestroyChild(child_id);
 847   EXPECT_EQ(0u, resource_provider_->num_resources());
 848
 849   ASSERT_EQ(4u, returned_to_child.size());
 850   EXPECT_NE(0u, returned_to_child[0].sync_point);
 851   EXPECT_NE(0u, returned_to_child[1].sync_point);
 852   EXPECT_NE(0u, returned_to_child[2].sync_point);
 853   EXPECT_NE(0u, returned_to_child[3].sync_point);
 854   EXPECT_FALSE(returned_to_child[0].lost);
 855   EXPECT_FALSE(returned_to_child[1].lost);
 856   EXPECT_FALSE(returned_to_child[2].lost);
 857   EXPECT_FALSE(returned_to_child[3].lost);
 858 }
 859
 860 TEST_P(ResourceProviderTest, ReadLockCountStopsReturnToChildOrDelete) {
 861   if (GetParam() != ResourceProvider::GLTexture)
 862     return;
 863   gfx::Size size(1, 1);
 864   ResourceFormat format = RGBA_8888;
 865
 866   ResourceProvider::ResourceId id1 = child_resource_provider_->CreateResource(
 867       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
 868   uint8_t data1[4] = {1, 2, 3, 4};
 869   gfx::Rect rect(size);
 870   child_resource_provider_->SetPixels(id1, data1, rect, rect, gfx::Vector2d());
 871
 872   ReturnedResourceArray returned_to_child;
 873   int child_id =
 874       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
 875   {
 876     // Transfer some resources to the parent.
 877     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
 878     resource_ids_to_transfer.push_back(id1);
 879     TransferableResourceArray list;
 880     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
 881                                                   &list);
 882     ASSERT_EQ(1u, list.size());
 883     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
 884
 885     resource_provider_->ReceiveFromChild(child_id, list);
 886
 887     resource_provider_->WaitSyncPointIfNeeded(list[0].id);
 888     ResourceProvider::ScopedReadLockGL lock(resource_provider_.get(),
 889                                             list[0].id);
 890
 891     resource_provider_->DeclareUsedResourcesFromChild(
 892         child_id, ResourceProvider::ResourceIdArray());
 893     EXPECT_EQ(0u, returned_to_child.size());
 894   }
 895
 896   EXPECT_EQ(1u, returned_to_child.size());
 897   child_resource_provider_->ReceiveReturnsFromParent(returned_to_child);
 898
 899   {
 900     child_resource_provider_->WaitSyncPointIfNeeded(id1);
 901     ResourceProvider::ScopedReadLockGL lock(child_resource_provider_.get(),
 902                                             id1);
 903     child_resource_provider_->DeleteResource(id1);
 904     EXPECT_EQ(1u, child_resource_provider_->num_resources());
 905     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
 906   }
 907
 908   EXPECT_EQ(0u, child_resource_provider_->num_resources());
 909   resource_provider_->DestroyChild(child_id);
 910 }
 911
 912 TEST_P(ResourceProviderTest, AllowOverlayTransfersToParent) {
 913   // Overlays only supported on the GL path.
 914   if (GetParam() != ResourceProvider::GLTexture)
 915     return;
 916
 917   uint32 sync_point = 0;
 918   TextureMailbox mailbox(gpu::Mailbox::Generate(), GL_TEXTURE_2D, sync_point);
 919   mailbox.set_allow_overlay(true);
 920   scoped_ptr<SingleReleaseCallbackImpl> release_callback =
 921       SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback));
 922   ResourceProvider::ResourceId id1 =
 923       child_resource_provider_->CreateResourceFromTextureMailbox(
 924           mailbox, release_callback.Pass());
 925
 926   TextureMailbox mailbox2(gpu::Mailbox::Generate(), GL_TEXTURE_2D, sync_point);
 927   mailbox2.set_allow_overlay(false);
 928   scoped_ptr<SingleReleaseCallbackImpl> release_callback2 =
 929       SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback));
 930   ResourceProvider::ResourceId id2 =
 931       child_resource_provider_->CreateResourceFromTextureMailbox(
 932           mailbox2, release_callback2.Pass());
 933
 934   ReturnedResourceArray returned_to_child;
 935   int child_id =
 936       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
 937
 938   // Transfer some resources to the parent.
 939   ResourceProvider::ResourceIdArray resource_ids_to_transfer;
 940   resource_ids_to_transfer.push_back(id1);
 941   resource_ids_to_transfer.push_back(id2);
 942   TransferableResourceArray list;
 943   child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
 944                                                 &list);
 945   ASSERT_EQ(2u, list.size());
 946   resource_provider_->ReceiveFromChild(child_id, list);
 947   EXPECT_TRUE(resource_provider_->AllowOverlay(list[0].id));
 948   EXPECT_FALSE(resource_provider_->AllowOverlay(list[1].id));
 949
 950   resource_provider_->DeclareUsedResourcesFromChild(
 951       child_id, ResourceProvider::ResourceIdArray());
 952
 953   EXPECT_EQ(2u, returned_to_child.size());
 954   child_resource_provider_->ReceiveReturnsFromParent(returned_to_child);
 955
 956   child_resource_provider_->DeleteResource(id1);
 957   child_resource_provider_->DeleteResource(id2);
 958   EXPECT_EQ(0u, child_resource_provider_->num_resources());
 959
 960   resource_provider_->DestroyChild(child_id);
 961 }
 962
 963 TEST_P(ResourceProviderTest, TransferSoftwareResources) {
 964   if (GetParam() != ResourceProvider::Bitmap)
 965     return;
 966
 967   gfx::Size size(1, 1);
 968   ResourceFormat format = RGBA_8888;
 969   size_t pixel_size = TextureSizeBytes(size, format);
 970   ASSERT_EQ(4U, pixel_size);
 971
 972   ResourceProvider::ResourceId id1 = child_resource_provider_->CreateResource(
 973       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
 974   uint8_t data1[4] = { 1, 2, 3, 4 };
 975   gfx::Rect rect(size);
 976   child_resource_provider_->SetPixels(id1, data1, rect, rect, gfx::Vector2d());
 977
 978   ResourceProvider::ResourceId id2 = child_resource_provider_->CreateResource(
 979       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
 980   uint8_t data2[4] = { 5, 5, 5, 5 };
 981   child_resource_provider_->SetPixels(id2, data2, rect, rect, gfx::Vector2d());
 982
 983   scoped_ptr<base::SharedMemory> shared_memory(new base::SharedMemory());
 984   shared_memory->CreateAndMapAnonymous(1);
 985   base::SharedMemory* shared_memory_ptr = shared_memory.get();
 986   ResourceProvider::ResourceId id3 =
 987       child_resource_provider_->CreateResourceFromTextureMailbox(
 988           TextureMailbox(shared_memory_ptr, gfx::Size(1, 1)),
 989           SingleReleaseCallbackImpl::Create(base::Bind(
 990               &SharedMemoryReleaseCallback, base::Passed(&shared_memory))));
 991
 992   ReturnedResourceArray returned_to_child;
 993   int child_id =
 994       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
 995   {
 996     // Transfer some resources to the parent.
 997     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
 998     resource_ids_to_transfer.push_back(id1);
 999     resource_ids_to_transfer.push_back(id2);
1000     resource_ids_to_transfer.push_back(id3);
1001     TransferableResourceArray list;
1002     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
1003                                                   &list);
1004     ASSERT_EQ(3u, list.size());
1005     EXPECT_EQ(0u, list[0].mailbox_holder.sync_point);
1006     EXPECT_EQ(0u, list[1].mailbox_holder.sync_point);
1007     EXPECT_EQ(0u, list[2].mailbox_holder.sync_point);
1008     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
1009     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id2));
1010     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id3));
1011     resource_provider_->ReceiveFromChild(child_id, list);
1012     resource_provider_->DeclareUsedResourcesFromChild(child_id,
1013                                                       resource_ids_to_transfer);
1014   }
1015
1016   EXPECT_EQ(3u, resource_provider_->num_resources());
1017   ResourceProvider::ResourceIdMap resource_map =
1018       resource_provider_->GetChildToParentMap(child_id);
1019   ResourceProvider::ResourceId mapped_id1 = resource_map[id1];
1020   ResourceProvider::ResourceId mapped_id2 = resource_map[id2];
1021   ResourceProvider::ResourceId mapped_id3 = resource_map[id3];
1022   EXPECT_NE(0u, mapped_id1);
1023   EXPECT_NE(0u, mapped_id2);
1024   EXPECT_NE(0u, mapped_id3);
1025   EXPECT_FALSE(resource_provider_->InUseByConsumer(id1));
1026   EXPECT_FALSE(resource_provider_->InUseByConsumer(id2));
1027   EXPECT_FALSE(resource_provider_->InUseByConsumer(id3));
1028
1029   uint8_t result[4] = { 0 };
1030   GetResourcePixels(
1031       resource_provider_.get(), context(), mapped_id1, size, format, result);
1032   EXPECT_EQ(0, memcmp(data1, result, pixel_size));
1033
1034   GetResourcePixels(
1035       resource_provider_.get(), context(), mapped_id2, size, format, result);
1036   EXPECT_EQ(0, memcmp(data2, result, pixel_size));
1037
1038   {
1039     // Check that transfering again the same resource from the child to the
1040     // parent works.
1041     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
1042     resource_ids_to_transfer.push_back(id1);
1043     resource_ids_to_transfer.push_back(id2);
1044     TransferableResourceArray list;
1045     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
1046                                                   &list);
1047     EXPECT_EQ(2u, list.size());
1048     EXPECT_EQ(id1, list[0].id);
1049     EXPECT_EQ(id2, list[1].id);
1050     ReturnedResourceArray returned;
1051     TransferableResource::ReturnResources(list, &returned);
1052     child_resource_provider_->ReceiveReturnsFromParent(returned);
1053     // ids were exported twice, we returned them only once, they should still
1054     // be in-use.
1055     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
1056     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id2));
1057   }
1058   {
1059     EXPECT_EQ(0u, returned_to_child.size());
1060
1061     // Transfer resources back from the parent to the child. Set no resources as
1062     // being in use.
1063     ResourceProvider::ResourceIdArray no_resources;
1064     resource_provider_->DeclareUsedResourcesFromChild(child_id, no_resources);
1065
1066     ASSERT_EQ(3u, returned_to_child.size());
1067     EXPECT_EQ(0u, returned_to_child[0].sync_point);
1068     EXPECT_EQ(0u, returned_to_child[1].sync_point);
1069     EXPECT_EQ(0u, returned_to_child[2].sync_point);
1070     std::set<ResourceProvider::ResourceId> expected_ids;
1071     expected_ids.insert(id1);
1072     expected_ids.insert(id2);
1073     expected_ids.insert(id3);
1074     std::set<ResourceProvider::ResourceId> returned_ids;
1075     for (unsigned i = 0; i < 3; i++)
1076       returned_ids.insert(returned_to_child[i].id);
1077     EXPECT_EQ(expected_ids, returned_ids);
1078     EXPECT_FALSE(returned_to_child[0].lost);
1079     EXPECT_FALSE(returned_to_child[1].lost);
1080     EXPECT_FALSE(returned_to_child[2].lost);
1081     child_resource_provider_->ReceiveReturnsFromParent(returned_to_child);
1082     returned_to_child.clear();
1083   }
1084   EXPECT_FALSE(child_resource_provider_->InUseByConsumer(id1));
1085   EXPECT_FALSE(child_resource_provider_->InUseByConsumer(id2));
1086   EXPECT_FALSE(child_resource_provider_->InUseByConsumer(id3));
1087
1088   {
1089     ResourceProvider::ScopedReadLockSoftware lock(
1090         child_resource_provider_.get(), id1);
1091     const SkBitmap* sk_bitmap = lock.sk_bitmap();
1092     EXPECT_EQ(sk_bitmap->width(), size.width());
1093     EXPECT_EQ(sk_bitmap->height(), size.height());
1094     EXPECT_EQ(0, memcmp(data1, sk_bitmap->getPixels(), pixel_size));
1095   }
1096   {
1097     ResourceProvider::ScopedReadLockSoftware lock(
1098         child_resource_provider_.get(), id2);
1099     const SkBitmap* sk_bitmap = lock.sk_bitmap();
1100     EXPECT_EQ(sk_bitmap->width(), size.width());
1101     EXPECT_EQ(sk_bitmap->height(), size.height());
1102     EXPECT_EQ(0, memcmp(data2, sk_bitmap->getPixels(), pixel_size));
1103   }
1104   {
1105     // Transfer resources to the parent again.
1106     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
1107     resource_ids_to_transfer.push_back(id1);
1108     resource_ids_to_transfer.push_back(id2);
1109     resource_ids_to_transfer.push_back(id3);
1110     TransferableResourceArray list;
1111     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
1112                                                   &list);
1113     ASSERT_EQ(3u, list.size());
1114     EXPECT_EQ(id1, list[0].id);
1115     EXPECT_EQ(id2, list[1].id);
1116     EXPECT_EQ(id3, list[2].id);
1117     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
1118     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id2));
1119     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id3));
1120     resource_provider_->ReceiveFromChild(child_id, list);
1121     resource_provider_->DeclareUsedResourcesFromChild(child_id,
1122                                                       resource_ids_to_transfer);
1123   }
1124
1125   EXPECT_EQ(0u, returned_to_child.size());
1126
1127   EXPECT_EQ(3u, resource_provider_->num_resources());
1128   resource_provider_->DestroyChild(child_id);
1129   EXPECT_EQ(0u, resource_provider_->num_resources());
1130
1131   ASSERT_EQ(3u, returned_to_child.size());
1132   EXPECT_EQ(0u, returned_to_child[0].sync_point);
1133   EXPECT_EQ(0u, returned_to_child[1].sync_point);
1134   EXPECT_EQ(0u, returned_to_child[2].sync_point);
1135   std::set<ResourceProvider::ResourceId> expected_ids;
1136   expected_ids.insert(id1);
1137   expected_ids.insert(id2);
1138   expected_ids.insert(id3);
1139   std::set<ResourceProvider::ResourceId> returned_ids;
1140   for (unsigned i = 0; i < 3; i++)
1141     returned_ids.insert(returned_to_child[i].id);
1142   EXPECT_EQ(expected_ids, returned_ids);
1143   EXPECT_FALSE(returned_to_child[0].lost);
1144   EXPECT_FALSE(returned_to_child[1].lost);
1145   EXPECT_FALSE(returned_to_child[2].lost);
1146 }
1147
1148 TEST_P(ResourceProviderTest, TransferGLToSoftware) {
1149   if (GetParam() != ResourceProvider::Bitmap)
1150     return;
1151
1152   scoped_ptr<ResourceProviderContext> child_context_owned(
1153       ResourceProviderContext::Create(shared_data_.get()));
1154
1155   FakeOutputSurfaceClient child_output_surface_client;
1156   scoped_ptr<OutputSurface> child_output_surface(FakeOutputSurface::Create3d(
1157       child_context_owned.PassAs<TestWebGraphicsContext3D>()));
1158   CHECK(child_output_surface->BindToClient(&child_output_surface_client));
1159
1160   scoped_ptr<ResourceProvider> child_resource_provider(
1161       ResourceProvider::Create(child_output_surface.get(),
1162                                shared_bitmap_manager_.get(),
1163                                NULL,
1164                                0,
1165                                false,
1166                                1,
1167                                false));
1168
1169   gfx::Size size(1, 1);
1170   ResourceFormat format = RGBA_8888;
1171   size_t pixel_size = TextureSizeBytes(size, format);
1172   ASSERT_EQ(4U, pixel_size);
1173
1174   ResourceProvider::ResourceId id1 = child_resource_provider->CreateResource(
1175       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
1176   uint8_t data1[4] = { 1, 2, 3, 4 };
1177   gfx::Rect rect(size);
1178   child_resource_provider->SetPixels(id1, data1, rect, rect, gfx::Vector2d());
1179
1180   ReturnedResourceArray returned_to_child;
1181   int child_id =
1182       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
1183   {
1184     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
1185     resource_ids_to_transfer.push_back(id1);
1186     TransferableResourceArray list;
1187     child_resource_provider->PrepareSendToParent(resource_ids_to_transfer,
1188                                                  &list);
1189     ASSERT_EQ(1u, list.size());
1190     EXPECT_NE(0u, list[0].mailbox_holder.sync_point);
1191     EXPECT_EQ(static_cast<GLenum>(GL_TEXTURE_2D),
1192               list[0].mailbox_holder.texture_target);
1193     EXPECT_TRUE(child_resource_provider->InUseByConsumer(id1));
1194     resource_provider_->ReceiveFromChild(child_id, list);
1195   }
1196
1197   EXPECT_EQ(0u, resource_provider_->num_resources());
1198   ASSERT_EQ(1u, returned_to_child.size());
1199   EXPECT_EQ(returned_to_child[0].id, id1);
1200   ResourceProvider::ResourceIdMap resource_map =
1201       resource_provider_->GetChildToParentMap(child_id);
1202   ResourceProvider::ResourceId mapped_id1 = resource_map[id1];
1203   EXPECT_EQ(0u, mapped_id1);
1204
1205   resource_provider_->DestroyChild(child_id);
1206   EXPECT_EQ(0u, resource_provider_->num_resources());
1207
1208   ASSERT_EQ(1u, returned_to_child.size());
1209   EXPECT_FALSE(returned_to_child[0].lost);
1210 }
1211
1212 TEST_P(ResourceProviderTest, TransferInvalidSoftware) {
1213   if (GetParam() != ResourceProvider::Bitmap)
1214     return;
1215
1216   gfx::Size size(1, 1);
1217   ResourceFormat format = RGBA_8888;
1218   size_t pixel_size = TextureSizeBytes(size, format);
1219   ASSERT_EQ(4U, pixel_size);
1220
1221   ResourceProvider::ResourceId id1 = child_resource_provider_->CreateResource(
1222       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
1223   uint8_t data1[4] = { 1, 2, 3, 4 };
1224   gfx::Rect rect(size);
1225   child_resource_provider_->SetPixels(id1, data1, rect, rect, gfx::Vector2d());
1226
1227   ReturnedResourceArray returned_to_child;
1228   int child_id =
1229       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
1230   {
1231     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
1232     resource_ids_to_transfer.push_back(id1);
1233     TransferableResourceArray list;
1234     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
1235                                                   &list);
1236     ASSERT_EQ(1u, list.size());
1237     // Make invalid.
1238     list[0].mailbox_holder.mailbox.name[1] = 5;
1239     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
1240     resource_provider_->ReceiveFromChild(child_id, list);
1241   }
1242
1243   EXPECT_EQ(1u, resource_provider_->num_resources());
1244   EXPECT_EQ(0u, returned_to_child.size());
1245
1246   ResourceProvider::ResourceIdMap resource_map =
1247       resource_provider_->GetChildToParentMap(child_id);
1248   ResourceProvider::ResourceId mapped_id1 = resource_map[id1];
1249   EXPECT_NE(0u, mapped_id1);
1250   {
1251     ResourceProvider::ScopedReadLockSoftware lock(resource_provider_.get(),
1252                                                   mapped_id1);
1253     EXPECT_FALSE(lock.valid());
1254   }
1255
1256   resource_provider_->DestroyChild(child_id);
1257   EXPECT_EQ(0u, resource_provider_->num_resources());
1258
1259   ASSERT_EQ(1u, returned_to_child.size());
1260   EXPECT_FALSE(returned_to_child[0].lost);
1261 }
1262
1263 TEST_P(ResourceProviderTest, DeleteExportedResources) {
1264   gfx::Size size(1, 1);
1265   ResourceFormat format = RGBA_8888;
1266   size_t pixel_size = TextureSizeBytes(size, format);
1267   ASSERT_EQ(4U, pixel_size);
1268
1269   ResourceProvider::ResourceId id1 = child_resource_provider_->CreateResource(
1270       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
1271   uint8_t data1[4] = { 1, 2, 3, 4 };
1272   gfx::Rect rect(size);
1273   child_resource_provider_->SetPixels(id1, data1, rect, rect, gfx::Vector2d());
1274
1275   ResourceProvider::ResourceId id2 = child_resource_provider_->CreateResource(
1276       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
1277   uint8_t data2[4] = {5, 5, 5, 5};
1278   child_resource_provider_->SetPixels(id2, data2, rect, rect, gfx::Vector2d());
1279
1280   ReturnedResourceArray returned_to_child;
1281   int child_id =
1282       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
1283   {
1284     // Transfer some resources to the parent.
1285     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
1286     resource_ids_to_transfer.push_back(id1);
1287     resource_ids_to_transfer.push_back(id2);
1288     TransferableResourceArray list;
1289     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
1290                                                   &list);
1291     ASSERT_EQ(2u, list.size());
1292     if (GetParam() == ResourceProvider::GLTexture) {
1293       EXPECT_NE(0u, list[0].mailbox_holder.sync_point);
1294       EXPECT_NE(0u, list[1].mailbox_holder.sync_point);
1295     }
1296     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
1297     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id2));
1298     resource_provider_->ReceiveFromChild(child_id, list);
1299     resource_provider_->DeclareUsedResourcesFromChild(child_id,
1300                                                       resource_ids_to_transfer);
1301   }
1302
1303   EXPECT_EQ(2u, resource_provider_->num_resources());
1304   ResourceProvider::ResourceIdMap resource_map =
1305       resource_provider_->GetChildToParentMap(child_id);
1306   ResourceProvider::ResourceId mapped_id1 = resource_map[id1];
1307   ResourceProvider::ResourceId mapped_id2 = resource_map[id2];
1308   EXPECT_NE(0u, mapped_id1);
1309   EXPECT_NE(0u, mapped_id2);
1310   EXPECT_FALSE(resource_provider_->InUseByConsumer(id1));
1311   EXPECT_FALSE(resource_provider_->InUseByConsumer(id2));
1312
1313   {
1314     // The parent transfers the resources to the grandparent.
1315     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
1316     resource_ids_to_transfer.push_back(mapped_id1);
1317     resource_ids_to_transfer.push_back(mapped_id2);
1318     TransferableResourceArray list;
1319     resource_provider_->PrepareSendToParent(resource_ids_to_transfer, &list);
1320
1321     ASSERT_EQ(2u, list.size());
1322     if (GetParam() == ResourceProvider::GLTexture) {
1323       EXPECT_NE(0u, list[0].mailbox_holder.sync_point);
1324       EXPECT_NE(0u, list[1].mailbox_holder.sync_point);
1325     }
1326     EXPECT_TRUE(resource_provider_->InUseByConsumer(id1));
1327     EXPECT_TRUE(resource_provider_->InUseByConsumer(id2));
1328
1329     // Release the resource in the parent. Set no resources as being in use. The
1330     // resources are exported so that can't be transferred back yet.
1331     ResourceProvider::ResourceIdArray no_resources;
1332     resource_provider_->DeclareUsedResourcesFromChild(child_id, no_resources);
1333
1334     EXPECT_EQ(0u, returned_to_child.size());
1335     EXPECT_EQ(2u, resource_provider_->num_resources());
1336
1337     // Return the resources from the grandparent to the parent. They should be
1338     // returned to the child then.
1339     EXPECT_EQ(2u, list.size());
1340     EXPECT_EQ(mapped_id1, list[0].id);
1341     EXPECT_EQ(mapped_id2, list[1].id);
1342     ReturnedResourceArray returned;
1343     TransferableResource::ReturnResources(list, &returned);
1344     resource_provider_->ReceiveReturnsFromParent(returned);
1345
1346     EXPECT_EQ(0u, resource_provider_->num_resources());
1347     ASSERT_EQ(2u, returned_to_child.size());
1348     if (GetParam() == ResourceProvider::GLTexture) {
1349       EXPECT_NE(0u, returned_to_child[0].sync_point);
1350       EXPECT_NE(0u, returned_to_child[1].sync_point);
1351     }
1352     EXPECT_FALSE(returned_to_child[0].lost);
1353     EXPECT_FALSE(returned_to_child[1].lost);
1354   }
1355 }
1356
1357 TEST_P(ResourceProviderTest, DestroyChildWithExportedResources) {
1358   gfx::Size size(1, 1);
1359   ResourceFormat format = RGBA_8888;
1360   size_t pixel_size = TextureSizeBytes(size, format);
1361   ASSERT_EQ(4U, pixel_size);
1362
1363   ResourceProvider::ResourceId id1 = child_resource_provider_->CreateResource(
1364       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
1365   uint8_t data1[4] = {1, 2, 3, 4};
1366   gfx::Rect rect(size);
1367   child_resource_provider_->SetPixels(id1, data1, rect, rect, gfx::Vector2d());
1368
1369   ResourceProvider::ResourceId id2 = child_resource_provider_->CreateResource(
1370       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
1371   uint8_t data2[4] = {5, 5, 5, 5};
1372   child_resource_provider_->SetPixels(id2, data2, rect, rect, gfx::Vector2d());
1373
1374   ReturnedResourceArray returned_to_child;
1375   int child_id =
1376       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
1377   {
1378     // Transfer some resources to the parent.
1379     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
1380     resource_ids_to_transfer.push_back(id1);
1381     resource_ids_to_transfer.push_back(id2);
1382     TransferableResourceArray list;
1383     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
1384                                                   &list);
1385     ASSERT_EQ(2u, list.size());
1386     if (GetParam() == ResourceProvider::GLTexture) {
1387       EXPECT_NE(0u, list[0].mailbox_holder.sync_point);
1388       EXPECT_NE(0u, list[1].mailbox_holder.sync_point);
1389     }
1390     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id1));
1391     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id2));
1392     resource_provider_->ReceiveFromChild(child_id, list);
1393     resource_provider_->DeclareUsedResourcesFromChild(child_id,
1394                                                       resource_ids_to_transfer);
1395   }
1396
1397   EXPECT_EQ(2u, resource_provider_->num_resources());
1398   ResourceProvider::ResourceIdMap resource_map =
1399       resource_provider_->GetChildToParentMap(child_id);
1400   ResourceProvider::ResourceId mapped_id1 = resource_map[id1];
1401   ResourceProvider::ResourceId mapped_id2 = resource_map[id2];
1402   EXPECT_NE(0u, mapped_id1);
1403   EXPECT_NE(0u, mapped_id2);
1404   EXPECT_FALSE(resource_provider_->InUseByConsumer(id1));
1405   EXPECT_FALSE(resource_provider_->InUseByConsumer(id2));
1406
1407   {
1408     // The parent transfers the resources to the grandparent.
1409     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
1410     resource_ids_to_transfer.push_back(mapped_id1);
1411     resource_ids_to_transfer.push_back(mapped_id2);
1412     TransferableResourceArray list;
1413     resource_provider_->PrepareSendToParent(resource_ids_to_transfer, &list);
1414
1415     ASSERT_EQ(2u, list.size());
1416     if (GetParam() == ResourceProvider::GLTexture) {
1417       EXPECT_NE(0u, list[0].mailbox_holder.sync_point);
1418       EXPECT_NE(0u, list[1].mailbox_holder.sync_point);
1419     }
1420     EXPECT_TRUE(resource_provider_->InUseByConsumer(id1));
1421     EXPECT_TRUE(resource_provider_->InUseByConsumer(id2));
1422
1423     // Release the resource in the parent. Set no resources as being in use. The
1424     // resources are exported so that can't be transferred back yet.
1425     ResourceProvider::ResourceIdArray no_resources;
1426     resource_provider_->DeclareUsedResourcesFromChild(child_id, no_resources);
1427
1428     // Destroy the child, the resources should not be returned yet.
1429     EXPECT_EQ(0u, returned_to_child.size());
1430     EXPECT_EQ(2u, resource_provider_->num_resources());
1431
1432     resource_provider_->DestroyChild(child_id);
1433
1434     EXPECT_EQ(2u, resource_provider_->num_resources());
1435     ASSERT_EQ(0u, returned_to_child.size());
1436
1437     // Return a resource from the grandparent, it should be returned at this
1438     // point.
1439     EXPECT_EQ(2u, list.size());
1440     EXPECT_EQ(mapped_id1, list[0].id);
1441     EXPECT_EQ(mapped_id2, list[1].id);
1442     TransferableResourceArray return_list;
1443     return_list.push_back(list[1]);
1444     list.pop_back();
1445     ReturnedResourceArray returned;
1446     TransferableResource::ReturnResources(return_list, &returned);
1447     resource_provider_->ReceiveReturnsFromParent(returned);
1448
1449     EXPECT_EQ(1u, resource_provider_->num_resources());
1450     ASSERT_EQ(1u, returned_to_child.size());
1451     if (GetParam() == ResourceProvider::GLTexture) {
1452       EXPECT_NE(0u, returned_to_child[0].sync_point);
1453     }
1454     EXPECT_FALSE(returned_to_child[0].lost);
1455     returned_to_child.clear();
1456
1457     // Destroy the parent resource provider. The resource that's left should be
1458     // lost at this point, and returned.
1459     resource_provider_.reset();
1460     ASSERT_EQ(1u, returned_to_child.size());
1461     if (GetParam() == ResourceProvider::GLTexture) {
1462       EXPECT_NE(0u, returned_to_child[0].sync_point);
1463     }
1464     EXPECT_TRUE(returned_to_child[0].lost);
1465   }
1466 }
1467
1468 TEST_P(ResourceProviderTest, DeleteTransferredResources) {
1469   gfx::Size size(1, 1);
1470   ResourceFormat format = RGBA_8888;
1471   size_t pixel_size = TextureSizeBytes(size, format);
1472   ASSERT_EQ(4U, pixel_size);
1473
1474   ResourceProvider::ResourceId id = child_resource_provider_->CreateResource(
1475       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
1476   uint8_t data[4] = { 1, 2, 3, 4 };
1477   gfx::Rect rect(size);
1478   child_resource_provider_->SetPixels(id, data, rect, rect, gfx::Vector2d());
1479
1480   ReturnedResourceArray returned_to_child;
1481   int child_id =
1482       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
1483   {
1484     // Transfer some resource to the parent.
1485     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
1486     resource_ids_to_transfer.push_back(id);
1487     TransferableResourceArray list;
1488     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
1489                                                   &list);
1490     ASSERT_EQ(1u, list.size());
1491     if (GetParam() == ResourceProvider::GLTexture)
1492       EXPECT_NE(0u, list[0].mailbox_holder.sync_point);
1493     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id));
1494     resource_provider_->ReceiveFromChild(child_id, list);
1495     resource_provider_->DeclareUsedResourcesFromChild(child_id,
1496                                                       resource_ids_to_transfer);
1497   }
1498
1499   // Delete textures in the child, while they are transfered.
1500   child_resource_provider_->DeleteResource(id);
1501   EXPECT_EQ(1u, child_resource_provider_->num_resources());
1502   {
1503     EXPECT_EQ(0u, returned_to_child.size());
1504
1505     // Transfer resources back from the parent to the child. Set no resources as
1506     // being in use.
1507     ResourceProvider::ResourceIdArray no_resources;
1508     resource_provider_->DeclareUsedResourcesFromChild(child_id, no_resources);
1509
1510     ASSERT_EQ(1u, returned_to_child.size());
1511     if (GetParam() == ResourceProvider::GLTexture)
1512       EXPECT_NE(0u, returned_to_child[0].sync_point);
1513     child_resource_provider_->ReceiveReturnsFromParent(returned_to_child);
1514   }
1515   EXPECT_EQ(0u, child_resource_provider_->num_resources());
1516 }
1517
1518 TEST_P(ResourceProviderTest, UnuseTransferredResources) {
1519   gfx::Size size(1, 1);
1520   ResourceFormat format = RGBA_8888;
1521   size_t pixel_size = TextureSizeBytes(size, format);
1522   ASSERT_EQ(4U, pixel_size);
1523
1524   ResourceProvider::ResourceId id = child_resource_provider_->CreateResource(
1525       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
1526   uint8_t data[4] = {1, 2, 3, 4};
1527   gfx::Rect rect(size);
1528   child_resource_provider_->SetPixels(id, data, rect, rect, gfx::Vector2d());
1529
1530   ReturnedResourceArray returned_to_child;
1531   int child_id =
1532       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
1533   const ResourceProvider::ResourceIdMap& map =
1534       resource_provider_->GetChildToParentMap(child_id);
1535   {
1536     // Transfer some resource to the parent.
1537     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
1538     resource_ids_to_transfer.push_back(id);
1539     TransferableResourceArray list;
1540     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
1541                                                   &list);
1542     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id));
1543     resource_provider_->ReceiveFromChild(child_id, list);
1544     resource_provider_->DeclareUsedResourcesFromChild(child_id,
1545                                                       resource_ids_to_transfer);
1546   }
1547   TransferableResourceArray sent_to_top_level;
1548   {
1549     // Parent transfers to top-level.
1550     ASSERT_TRUE(map.find(id) != map.end());
1551     ResourceProvider::ResourceId parent_id = map.find(id)->second;
1552     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
1553     resource_ids_to_transfer.push_back(parent_id);
1554     resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
1555                                             &sent_to_top_level);
1556     EXPECT_TRUE(resource_provider_->InUseByConsumer(parent_id));
1557   }
1558   {
1559     // Stop using resource.
1560     ResourceProvider::ResourceIdArray empty;
1561     resource_provider_->DeclareUsedResourcesFromChild(child_id, empty);
1562     // Resource is not yet returned to the child, since it's in use by the
1563     // top-level.
1564     EXPECT_TRUE(returned_to_child.empty());
1565   }
1566   {
1567     // Send the resource to the parent again.
1568     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
1569     resource_ids_to_transfer.push_back(id);
1570     TransferableResourceArray list;
1571     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
1572                                                   &list);
1573     EXPECT_TRUE(child_resource_provider_->InUseByConsumer(id));
1574     resource_provider_->ReceiveFromChild(child_id, list);
1575     resource_provider_->DeclareUsedResourcesFromChild(child_id,
1576                                                       resource_ids_to_transfer);
1577   }
1578   {
1579     // Receive returns back from top-level.
1580     ReturnedResourceArray returned;
1581     TransferableResource::ReturnResources(sent_to_top_level, &returned);
1582     resource_provider_->ReceiveReturnsFromParent(returned);
1583     // Resource is still not yet returned to the child, since it's declared used
1584     // in the parent.
1585     EXPECT_TRUE(returned_to_child.empty());
1586     ASSERT_TRUE(map.find(id) != map.end());
1587     ResourceProvider::ResourceId parent_id = map.find(id)->second;
1588     EXPECT_FALSE(resource_provider_->InUseByConsumer(parent_id));
1589   }
1590   {
1591     sent_to_top_level.clear();
1592     // Parent transfers again to top-level.
1593     ASSERT_TRUE(map.find(id) != map.end());
1594     ResourceProvider::ResourceId parent_id = map.find(id)->second;
1595     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
1596     resource_ids_to_transfer.push_back(parent_id);
1597     resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
1598                                             &sent_to_top_level);
1599     EXPECT_TRUE(resource_provider_->InUseByConsumer(parent_id));
1600   }
1601   {
1602     // Receive returns back from top-level.
1603     ReturnedResourceArray returned;
1604     TransferableResource::ReturnResources(sent_to_top_level, &returned);
1605     resource_provider_->ReceiveReturnsFromParent(returned);
1606     // Resource is still not yet returned to the child, since it's still
1607     // declared used in the parent.
1608     EXPECT_TRUE(returned_to_child.empty());
1609     ASSERT_TRUE(map.find(id) != map.end());
1610     ResourceProvider::ResourceId parent_id = map.find(id)->second;
1611     EXPECT_FALSE(resource_provider_->InUseByConsumer(parent_id));
1612   }
1613   {
1614     // Stop using resource.
1615     ResourceProvider::ResourceIdArray empty;
1616     resource_provider_->DeclareUsedResourcesFromChild(child_id, empty);
1617     // Resource should have been returned to the child, since it's no longer in
1618     // use by the top-level.
1619     ASSERT_EQ(1u, returned_to_child.size());
1620     EXPECT_EQ(id, returned_to_child[0].id);
1621     EXPECT_EQ(2, returned_to_child[0].count);
1622     child_resource_provider_->ReceiveReturnsFromParent(returned_to_child);
1623     returned_to_child.clear();
1624     EXPECT_FALSE(child_resource_provider_->InUseByConsumer(id));
1625   }
1626 }
1627
1628 class ResourceProviderTestTextureFilters : public ResourceProviderTest {
1629  public:
1630   static void RunTest(GLenum child_filter, GLenum parent_filter) {
1631     scoped_ptr<TextureStateTrackingContext> child_context_owned(
1632         new TextureStateTrackingContext);
1633     TextureStateTrackingContext* child_context = child_context_owned.get();
1634
1635     FakeOutputSurfaceClient child_output_surface_client;
1636     scoped_ptr<OutputSurface> child_output_surface(FakeOutputSurface::Create3d(
1637         child_context_owned.PassAs<TestWebGraphicsContext3D>()));
1638     CHECK(child_output_surface->BindToClient(&child_output_surface_client));
1639     scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
1640         new TestSharedBitmapManager());
1641
1642     scoped_ptr<ResourceProvider> child_resource_provider(
1643         ResourceProvider::Create(child_output_surface.get(),
1644                                  shared_bitmap_manager.get(),
1645                                  NULL,
1646                                  0,
1647                                  false,
1648                                  1,
1649                                  false));
1650
1651     scoped_ptr<TextureStateTrackingContext> parent_context_owned(
1652         new TextureStateTrackingContext);
1653     TextureStateTrackingContext* parent_context = parent_context_owned.get();
1654
1655     FakeOutputSurfaceClient parent_output_surface_client;
1656     scoped_ptr<OutputSurface> parent_output_surface(FakeOutputSurface::Create3d(
1657         parent_context_owned.PassAs<TestWebGraphicsContext3D>()));
1658     CHECK(parent_output_surface->BindToClient(&parent_output_surface_client));
1659
1660     scoped_ptr<ResourceProvider> parent_resource_provider(
1661         ResourceProvider::Create(parent_output_surface.get(),
1662                                  shared_bitmap_manager.get(),
1663                                  NULL,
1664                                  0,
1665                                  false,
1666                                  1,
1667                                  false));
1668
1669     gfx::Size size(1, 1);
1670     ResourceFormat format = RGBA_8888;
1671     int child_texture_id = 1;
1672     int parent_texture_id = 2;
1673
1674     size_t pixel_size = TextureSizeBytes(size, format);
1675     ASSERT_EQ(4U, pixel_size);
1676
1677     ResourceProvider::ResourceId id = child_resource_provider->CreateResource(
1678         size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
1679
1680     // The new texture is created with GL_LINEAR.
1681     EXPECT_CALL(*child_context, bindTexture(GL_TEXTURE_2D, child_texture_id))
1682         .Times(2);  // Once to create and once to allocate.
1683     EXPECT_CALL(*child_context,
1684                 texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
1685     EXPECT_CALL(*child_context,
1686                 texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
1687     EXPECT_CALL(
1688         *child_context,
1689         texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
1690     EXPECT_CALL(
1691         *child_context,
1692         texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
1693     EXPECT_CALL(*child_context,
1694                 texParameteri(GL_TEXTURE_2D,
1695                               GL_TEXTURE_POOL_CHROMIUM,
1696                               GL_TEXTURE_POOL_UNMANAGED_CHROMIUM));
1697     child_resource_provider->AllocateForTesting(id);
1698     Mock::VerifyAndClearExpectations(child_context);
1699
1700     uint8_t data[4] = { 1, 2, 3, 4 };
1701     gfx::Rect rect(size);
1702
1703     EXPECT_CALL(*child_context, bindTexture(GL_TEXTURE_2D, child_texture_id));
1704     child_resource_provider->SetPixels(id, data, rect, rect, gfx::Vector2d());
1705     Mock::VerifyAndClearExpectations(child_context);
1706
1707     // The texture is set to |child_filter| in the child.
1708     EXPECT_CALL(*child_context, bindTexture(GL_TEXTURE_2D, child_texture_id));
1709     if (child_filter != GL_LINEAR) {
1710       EXPECT_CALL(
1711           *child_context,
1712           texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, child_filter));
1713       EXPECT_CALL(
1714           *child_context,
1715           texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, child_filter));
1716     }
1717     SetResourceFilter(child_resource_provider.get(), id, child_filter);
1718     Mock::VerifyAndClearExpectations(child_context);
1719
1720     ReturnedResourceArray returned_to_child;
1721     int child_id = parent_resource_provider->CreateChild(
1722         GetReturnCallback(&returned_to_child));
1723     {
1724       // Transfer some resource to the parent.
1725       ResourceProvider::ResourceIdArray resource_ids_to_transfer;
1726       resource_ids_to_transfer.push_back(id);
1727       TransferableResourceArray list;
1728
1729       EXPECT_CALL(*child_context, bindTexture(GL_TEXTURE_2D, child_texture_id));
1730       EXPECT_CALL(*child_context,
1731                   produceTextureCHROMIUM(GL_TEXTURE_2D, _));
1732       EXPECT_CALL(*child_context, insertSyncPoint());
1733       child_resource_provider->PrepareSendToParent(resource_ids_to_transfer,
1734                                                    &list);
1735       Mock::VerifyAndClearExpectations(child_context);
1736
1737       ASSERT_EQ(1u, list.size());
1738       EXPECT_EQ(static_cast<unsigned>(child_filter), list[0].filter);
1739
1740       EXPECT_CALL(*parent_context,
1741                   bindTexture(GL_TEXTURE_2D, parent_texture_id));
1742       EXPECT_CALL(*parent_context, consumeTextureCHROMIUM(GL_TEXTURE_2D, _));
1743       parent_resource_provider->ReceiveFromChild(child_id, list);
1744       {
1745         parent_resource_provider->WaitSyncPointIfNeeded(list[0].id);
1746         ResourceProvider::ScopedReadLockGL lock(parent_resource_provider.get(),
1747                                                 list[0].id);
1748       }
1749       Mock::VerifyAndClearExpectations(parent_context);
1750
1751       parent_resource_provider->DeclareUsedResourcesFromChild(
1752           child_id, resource_ids_to_transfer);
1753       Mock::VerifyAndClearExpectations(parent_context);
1754     }
1755     ResourceProvider::ResourceIdMap resource_map =
1756         parent_resource_provider->GetChildToParentMap(child_id);
1757     ResourceProvider::ResourceId mapped_id = resource_map[id];
1758     EXPECT_NE(0u, mapped_id);
1759
1760     // The texture is set to |parent_filter| in the parent.
1761     EXPECT_CALL(*parent_context, bindTexture(GL_TEXTURE_2D, parent_texture_id));
1762     EXPECT_CALL(
1763         *parent_context,
1764         texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, parent_filter));
1765     EXPECT_CALL(
1766         *parent_context,
1767         texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, parent_filter));
1768     SetResourceFilter(parent_resource_provider.get(), mapped_id, parent_filter);
1769     Mock::VerifyAndClearExpectations(parent_context);
1770
1771     // The texture should be reset to |child_filter| in the parent when it is
1772     // returned, since that is how it was received.
1773     EXPECT_CALL(*parent_context, bindTexture(GL_TEXTURE_2D, parent_texture_id));
1774     EXPECT_CALL(
1775         *parent_context,
1776         texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, child_filter));
1777     EXPECT_CALL(
1778         *parent_context,
1779         texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, child_filter));
1780
1781     {
1782       EXPECT_EQ(0u, returned_to_child.size());
1783
1784       // Transfer resources back from the parent to the child. Set no resources
1785       // as being in use.
1786       ResourceProvider::ResourceIdArray no_resources;
1787       EXPECT_CALL(*parent_context, insertSyncPoint());
1788       parent_resource_provider->DeclareUsedResourcesFromChild(child_id,
1789                                                               no_resources);
1790       Mock::VerifyAndClearExpectations(parent_context);
1791
1792       ASSERT_EQ(1u, returned_to_child.size());
1793       child_resource_provider->ReceiveReturnsFromParent(returned_to_child);
1794     }
1795
1796     // The child remembers the texture filter is set to |child_filter|.
1797     EXPECT_CALL(*child_context, bindTexture(GL_TEXTURE_2D, child_texture_id));
1798     SetResourceFilter(child_resource_provider.get(), id, child_filter);
1799     Mock::VerifyAndClearExpectations(child_context);
1800   }
1801 };
1802
1803 TEST_P(ResourceProviderTest, TextureFilters_ChildNearestParentLinear) {
1804   if (GetParam() != ResourceProvider::GLTexture)
1805     return;
1806   ResourceProviderTestTextureFilters::RunTest(GL_NEAREST, GL_LINEAR);
1807 }
1808
1809 TEST_P(ResourceProviderTest, TextureFilters_ChildLinearParentNearest) {
1810   if (GetParam() != ResourceProvider::GLTexture)
1811     return;
1812   ResourceProviderTestTextureFilters::RunTest(GL_LINEAR, GL_NEAREST);
1813 }
1814
1815 TEST_P(ResourceProviderTest, TransferMailboxResources) {
1816   // Other mailbox transfers tested elsewhere.
1817   if (GetParam() != ResourceProvider::GLTexture)
1818     return;
1819   unsigned texture = context()->createTexture();
1820   context()->bindTexture(GL_TEXTURE_2D, texture);
1821   uint8_t data[4] = { 1, 2, 3, 4 };
1822   context()->texImage2D(
1823       GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, &data);
1824   gpu::Mailbox mailbox;
1825   context()->genMailboxCHROMIUM(mailbox.name);
1826   context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
1827   uint32 sync_point = context()->insertSyncPoint();
1828
1829   // All the logic below assumes that the sync points are all positive.
1830   EXPECT_LT(0u, sync_point);
1831
1832   uint32 release_sync_point = 0;
1833   bool lost_resource = false;
1834   BlockingTaskRunner* main_thread_task_runner = NULL;
1835   ReleaseCallbackImpl callback = base::Bind(ReleaseCallback,
1836                                             &release_sync_point,
1837                                             &lost_resource,
1838                                             &main_thread_task_runner);
1839   ResourceProvider::ResourceId resource =
1840       resource_provider_->CreateResourceFromTextureMailbox(
1841           TextureMailbox(mailbox, GL_TEXTURE_2D, sync_point),
1842           SingleReleaseCallbackImpl::Create(callback));
1843   EXPECT_EQ(1u, context()->NumTextures());
1844   EXPECT_EQ(0u, release_sync_point);
1845   {
1846     // Transfer the resource, expect the sync points to be consistent.
1847     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
1848     resource_ids_to_transfer.push_back(resource);
1849     TransferableResourceArray list;
1850     resource_provider_->PrepareSendToParent(resource_ids_to_transfer, &list);
1851     ASSERT_EQ(1u, list.size());
1852     EXPECT_LE(sync_point, list[0].mailbox_holder.sync_point);
1853     EXPECT_EQ(0,
1854               memcmp(mailbox.name,
1855                      list[0].mailbox_holder.mailbox.name,
1856                      sizeof(mailbox.name)));
1857     EXPECT_EQ(0u, release_sync_point);
1858
1859     context()->waitSyncPoint(list[0].mailbox_holder.sync_point);
1860     unsigned other_texture = context()->createTexture();
1861     context()->bindTexture(GL_TEXTURE_2D, other_texture);
1862     context()->consumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
1863     uint8_t test_data[4] = { 0 };
1864     context()->GetPixels(
1865         gfx::Size(1, 1), RGBA_8888, test_data);
1866     EXPECT_EQ(0, memcmp(data, test_data, sizeof(data)));
1867     context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
1868     context()->deleteTexture(other_texture);
1869     list[0].mailbox_holder.sync_point = context()->insertSyncPoint();
1870     EXPECT_LT(0u, list[0].mailbox_holder.sync_point);
1871
1872     // Receive the resource, then delete it, expect the sync points to be
1873     // consistent.
1874     ReturnedResourceArray returned;
1875     TransferableResource::ReturnResources(list, &returned);
1876     resource_provider_->ReceiveReturnsFromParent(returned);
1877     EXPECT_EQ(1u, context()->NumTextures());
1878     EXPECT_EQ(0u, release_sync_point);
1879
1880     resource_provider_->DeleteResource(resource);
1881     EXPECT_LE(list[0].mailbox_holder.sync_point, release_sync_point);
1882     EXPECT_FALSE(lost_resource);
1883     EXPECT_EQ(main_thread_task_runner_.get(), main_thread_task_runner);
1884   }
1885
1886   // We're going to do the same thing as above, but testing the case where we
1887   // delete the resource before we receive it back.
1888   sync_point = release_sync_point;
1889   EXPECT_LT(0u, sync_point);
1890   release_sync_point = 0;
1891   resource = resource_provider_->CreateResourceFromTextureMailbox(
1892       TextureMailbox(mailbox, GL_TEXTURE_2D, sync_point),
1893       SingleReleaseCallbackImpl::Create(callback));
1894   EXPECT_EQ(1u, context()->NumTextures());
1895   EXPECT_EQ(0u, release_sync_point);
1896   {
1897     // Transfer the resource, expect the sync points to be consistent.
1898     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
1899     resource_ids_to_transfer.push_back(resource);
1900     TransferableResourceArray list;
1901     resource_provider_->PrepareSendToParent(resource_ids_to_transfer, &list);
1902     ASSERT_EQ(1u, list.size());
1903     EXPECT_LE(sync_point, list[0].mailbox_holder.sync_point);
1904     EXPECT_EQ(0,
1905               memcmp(mailbox.name,
1906                      list[0].mailbox_holder.mailbox.name,
1907                      sizeof(mailbox.name)));
1908     EXPECT_EQ(0u, release_sync_point);
1909
1910     context()->waitSyncPoint(list[0].mailbox_holder.sync_point);
1911     unsigned other_texture = context()->createTexture();
1912     context()->bindTexture(GL_TEXTURE_2D, other_texture);
1913     context()->consumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
1914     uint8_t test_data[4] = { 0 };
1915     context()->GetPixels(
1916         gfx::Size(1, 1), RGBA_8888, test_data);
1917     EXPECT_EQ(0, memcmp(data, test_data, sizeof(data)));
1918     context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
1919     context()->deleteTexture(other_texture);
1920     list[0].mailbox_holder.sync_point = context()->insertSyncPoint();
1921     EXPECT_LT(0u, list[0].mailbox_holder.sync_point);
1922
1923     // Delete the resource, which shouldn't do anything.
1924     resource_provider_->DeleteResource(resource);
1925     EXPECT_EQ(1u, context()->NumTextures());
1926     EXPECT_EQ(0u, release_sync_point);
1927
1928     // Then receive the resource which should release the mailbox, expect the
1929     // sync points to be consistent.
1930     ReturnedResourceArray returned;
1931     TransferableResource::ReturnResources(list, &returned);
1932     resource_provider_->ReceiveReturnsFromParent(returned);
1933     EXPECT_LE(list[0].mailbox_holder.sync_point, release_sync_point);
1934     EXPECT_FALSE(lost_resource);
1935     EXPECT_EQ(main_thread_task_runner_.get(), main_thread_task_runner);
1936   }
1937
1938   context()->waitSyncPoint(release_sync_point);
1939   context()->bindTexture(GL_TEXTURE_2D, texture);
1940   context()->consumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
1941   context()->deleteTexture(texture);
1942 }
1943
1944 TEST_P(ResourceProviderTest, LostResourceInParent) {
1945   gfx::Size size(1, 1);
1946   ResourceFormat format = RGBA_8888;
1947   ResourceProvider::ResourceId resource =
1948       child_resource_provider_->CreateResource(
1949           size,
1950           GL_CLAMP_TO_EDGE,
1951           ResourceProvider::TextureHintImmutable,
1952           format);
1953   child_resource_provider_->AllocateForTesting(resource);
1954   // Expect a GL resource to be lost.
1955   bool should_lose_resource = GetParam() == ResourceProvider::GLTexture;
1956
1957   ReturnedResourceArray returned_to_child;
1958   int child_id =
1959       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
1960   {
1961     // Transfer the resource to the parent.
1962     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
1963     resource_ids_to_transfer.push_back(resource);
1964     TransferableResourceArray list;
1965     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
1966                                                   &list);
1967     EXPECT_EQ(1u, list.size());
1968
1969     resource_provider_->ReceiveFromChild(child_id, list);
1970     resource_provider_->DeclareUsedResourcesFromChild(child_id,
1971                                                       resource_ids_to_transfer);
1972   }
1973
1974   // Lose the output surface in the parent.
1975   resource_provider_->DidLoseOutputSurface();
1976
1977   {
1978     EXPECT_EQ(0u, returned_to_child.size());
1979
1980     // Transfer resources back from the parent to the child. Set no resources as
1981     // being in use.
1982     ResourceProvider::ResourceIdArray no_resources;
1983     resource_provider_->DeclareUsedResourcesFromChild(child_id, no_resources);
1984
1985     // Expect a GL resource to be lost.
1986     ASSERT_EQ(1u, returned_to_child.size());
1987     EXPECT_EQ(should_lose_resource, returned_to_child[0].lost);
1988     child_resource_provider_->ReceiveReturnsFromParent(returned_to_child);
1989     returned_to_child.clear();
1990   }
1991
1992   // A GL resource should be lost.
1993   EXPECT_EQ(should_lose_resource, child_resource_provider_->IsLost(resource));
1994
1995   // Lost resources stay in use in the parent forever.
1996   EXPECT_EQ(should_lose_resource,
1997             child_resource_provider_->InUseByConsumer(resource));
1998 }
1999
2000 TEST_P(ResourceProviderTest, LostResourceInGrandParent) {
2001   gfx::Size size(1, 1);
2002   ResourceFormat format = RGBA_8888;
2003   ResourceProvider::ResourceId resource =
2004       child_resource_provider_->CreateResource(
2005           size,
2006           GL_CLAMP_TO_EDGE,
2007           ResourceProvider::TextureHintImmutable,
2008           format);
2009   child_resource_provider_->AllocateForTesting(resource);
2010
2011   ReturnedResourceArray returned_to_child;
2012   int child_id =
2013       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
2014   {
2015     // Transfer the resource to the parent.
2016     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
2017     resource_ids_to_transfer.push_back(resource);
2018     TransferableResourceArray list;
2019     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
2020                                                   &list);
2021     EXPECT_EQ(1u, list.size());
2022
2023     resource_provider_->ReceiveFromChild(child_id, list);
2024     resource_provider_->DeclareUsedResourcesFromChild(child_id,
2025                                                       resource_ids_to_transfer);
2026   }
2027
2028   {
2029     ResourceProvider::ResourceIdMap resource_map =
2030         resource_provider_->GetChildToParentMap(child_id);
2031     ResourceProvider::ResourceId parent_resource = resource_map[resource];
2032     EXPECT_NE(0u, parent_resource);
2033
2034     // Transfer to a grandparent.
2035     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
2036     resource_ids_to_transfer.push_back(parent_resource);
2037     TransferableResourceArray list;
2038     resource_provider_->PrepareSendToParent(resource_ids_to_transfer, &list);
2039
2040     // Receive back a lost resource from the grandparent.
2041     EXPECT_EQ(1u, list.size());
2042     EXPECT_EQ(parent_resource, list[0].id);
2043     ReturnedResourceArray returned;
2044     TransferableResource::ReturnResources(list, &returned);
2045     EXPECT_EQ(1u, returned.size());
2046     EXPECT_EQ(parent_resource, returned[0].id);
2047     returned[0].lost = true;
2048     resource_provider_->ReceiveReturnsFromParent(returned);
2049
2050     // The resource should be lost.
2051     EXPECT_TRUE(resource_provider_->IsLost(parent_resource));
2052
2053     // Lost resources stay in use in the parent forever.
2054     EXPECT_TRUE(resource_provider_->InUseByConsumer(parent_resource));
2055   }
2056
2057   {
2058     EXPECT_EQ(0u, returned_to_child.size());
2059
2060     // Transfer resources back from the parent to the child. Set no resources as
2061     // being in use.
2062     ResourceProvider::ResourceIdArray no_resources;
2063     resource_provider_->DeclareUsedResourcesFromChild(child_id, no_resources);
2064
2065     // Expect the resource to be lost.
2066     ASSERT_EQ(1u, returned_to_child.size());
2067     EXPECT_TRUE(returned_to_child[0].lost);
2068     child_resource_provider_->ReceiveReturnsFromParent(returned_to_child);
2069     returned_to_child.clear();
2070   }
2071
2072   // The resource should be lost.
2073   EXPECT_TRUE(child_resource_provider_->IsLost(resource));
2074
2075   // Lost resources stay in use in the parent forever.
2076   EXPECT_TRUE(child_resource_provider_->InUseByConsumer(resource));
2077 }
2078
2079 TEST_P(ResourceProviderTest, LostMailboxInParent) {
2080   uint32 release_sync_point = 0;
2081   bool lost_resource = false;
2082   bool release_called = false;
2083   uint32 sync_point = 0;
2084   ResourceProvider::ResourceId resource = CreateChildMailbox(
2085       &release_sync_point, &lost_resource, &release_called, &sync_point);
2086
2087   ReturnedResourceArray returned_to_child;
2088   int child_id =
2089       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
2090   {
2091     // Transfer the resource to the parent.
2092     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
2093     resource_ids_to_transfer.push_back(resource);
2094     TransferableResourceArray list;
2095     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
2096                                                   &list);
2097     EXPECT_EQ(1u, list.size());
2098
2099     resource_provider_->ReceiveFromChild(child_id, list);
2100     resource_provider_->DeclareUsedResourcesFromChild(child_id,
2101                                                       resource_ids_to_transfer);
2102   }
2103
2104   // Lose the output surface in the parent.
2105   resource_provider_->DidLoseOutputSurface();
2106
2107   {
2108     EXPECT_EQ(0u, returned_to_child.size());
2109
2110     // Transfer resources back from the parent to the child. Set no resources as
2111     // being in use.
2112     ResourceProvider::ResourceIdArray no_resources;
2113     resource_provider_->DeclareUsedResourcesFromChild(child_id, no_resources);
2114
2115     ASSERT_EQ(1u, returned_to_child.size());
2116     // Losing an output surface only loses hardware resources.
2117     EXPECT_EQ(returned_to_child[0].lost,
2118               GetParam() == ResourceProvider::GLTexture);
2119     child_resource_provider_->ReceiveReturnsFromParent(returned_to_child);
2120     returned_to_child.clear();
2121   }
2122
2123   // Delete the resource in the child. Expect the resource to be lost if it's
2124   // a GL texture.
2125   child_resource_provider_->DeleteResource(resource);
2126   EXPECT_EQ(lost_resource, GetParam() == ResourceProvider::GLTexture);
2127 }
2128
2129 TEST_P(ResourceProviderTest, LostMailboxInGrandParent) {
2130   uint32 release_sync_point = 0;
2131   bool lost_resource = false;
2132   bool release_called = false;
2133   uint32 sync_point = 0;
2134   ResourceProvider::ResourceId resource = CreateChildMailbox(
2135       &release_sync_point, &lost_resource, &release_called, &sync_point);
2136
2137   ReturnedResourceArray returned_to_child;
2138   int child_id =
2139       resource_provider_->CreateChild(GetReturnCallback(&returned_to_child));
2140   {
2141     // Transfer the resource to the parent.
2142     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
2143     resource_ids_to_transfer.push_back(resource);
2144     TransferableResourceArray list;
2145     child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
2146                                                   &list);
2147     EXPECT_EQ(1u, list.size());
2148
2149     resource_provider_->ReceiveFromChild(child_id, list);
2150     resource_provider_->DeclareUsedResourcesFromChild(child_id,
2151                                                       resource_ids_to_transfer);
2152   }
2153
2154   {
2155     ResourceProvider::ResourceIdMap resource_map =
2156         resource_provider_->GetChildToParentMap(child_id);
2157     ResourceProvider::ResourceId parent_resource = resource_map[resource];
2158     EXPECT_NE(0u, parent_resource);
2159
2160     // Transfer to a grandparent.
2161     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
2162     resource_ids_to_transfer.push_back(parent_resource);
2163     TransferableResourceArray list;
2164     resource_provider_->PrepareSendToParent(resource_ids_to_transfer, &list);
2165
2166     // Receive back a lost resource from the grandparent.
2167     EXPECT_EQ(1u, list.size());
2168     EXPECT_EQ(parent_resource, list[0].id);
2169     ReturnedResourceArray returned;
2170     TransferableResource::ReturnResources(list, &returned);
2171     EXPECT_EQ(1u, returned.size());
2172     EXPECT_EQ(parent_resource, returned[0].id);
2173     returned[0].lost = true;
2174     resource_provider_->ReceiveReturnsFromParent(returned);
2175   }
2176
2177   {
2178     EXPECT_EQ(0u, returned_to_child.size());
2179
2180     // Transfer resources back from the parent to the child. Set no resources as
2181     // being in use.
2182     ResourceProvider::ResourceIdArray no_resources;
2183     resource_provider_->DeclareUsedResourcesFromChild(child_id, no_resources);
2184
2185     // Expect the resource to be lost.
2186     ASSERT_EQ(1u, returned_to_child.size());
2187     EXPECT_TRUE(returned_to_child[0].lost);
2188     child_resource_provider_->ReceiveReturnsFromParent(returned_to_child);
2189     returned_to_child.clear();
2190   }
2191
2192   // Delete the resource in the child. Expect the resource to be lost.
2193   child_resource_provider_->DeleteResource(resource);
2194   EXPECT_TRUE(lost_resource);
2195 }
2196
2197 TEST_P(ResourceProviderTest, Shutdown) {
2198   uint32 release_sync_point = 0;
2199   bool lost_resource = false;
2200   bool release_called = false;
2201   uint32 sync_point = 0;
2202   CreateChildMailbox(
2203       &release_sync_point, &lost_resource, &release_called, &sync_point);
2204
2205   EXPECT_EQ(0u, release_sync_point);
2206   EXPECT_FALSE(lost_resource);
2207
2208   child_resource_provider_.reset();
2209
2210   if (GetParam() == ResourceProvider::GLTexture) {
2211     EXPECT_LE(sync_point, release_sync_point);
2212   }
2213   EXPECT_TRUE(release_called);
2214   EXPECT_FALSE(lost_resource);
2215 }
2216
2217 TEST_P(ResourceProviderTest, ShutdownWithExportedResource) {
2218   uint32 release_sync_point = 0;
2219   bool lost_resource = false;
2220   bool release_called = false;
2221   uint32 sync_point = 0;
2222   ResourceProvider::ResourceId resource = CreateChildMailbox(
2223       &release_sync_point, &lost_resource, &release_called, &sync_point);
2224
2225   // Transfer the resource, so we can't release it properly on shutdown.
2226   ResourceProvider::ResourceIdArray resource_ids_to_transfer;
2227   resource_ids_to_transfer.push_back(resource);
2228   TransferableResourceArray list;
2229   child_resource_provider_->PrepareSendToParent(resource_ids_to_transfer,
2230                                                 &list);
2231
2232   EXPECT_EQ(0u, release_sync_point);
2233   EXPECT_FALSE(lost_resource);
2234
2235   child_resource_provider_.reset();
2236
2237   // Since the resource is in the parent, the child considers it lost.
2238   EXPECT_EQ(0u, release_sync_point);
2239   EXPECT_TRUE(lost_resource);
2240 }
2241
2242 TEST_P(ResourceProviderTest, LostContext) {
2243   // TextureMailbox callbacks only exist for GL textures for now.
2244   if (GetParam() != ResourceProvider::GLTexture)
2245     return;
2246   unsigned texture = context()->createTexture();
2247   context()->bindTexture(GL_TEXTURE_2D, texture);
2248   gpu::Mailbox mailbox;
2249   context()->genMailboxCHROMIUM(mailbox.name);
2250   context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
2251   uint32 sync_point = context()->insertSyncPoint();
2252
2253   EXPECT_LT(0u, sync_point);
2254
2255   uint32 release_sync_point = 0;
2256   bool lost_resource = false;
2257   BlockingTaskRunner* main_thread_task_runner = NULL;
2258   scoped_ptr<SingleReleaseCallbackImpl> callback =
2259       SingleReleaseCallbackImpl::Create(base::Bind(ReleaseCallback,
2260                                                    &release_sync_point,
2261                                                    &lost_resource,
2262                                                    &main_thread_task_runner));
2263   resource_provider_->CreateResourceFromTextureMailbox(
2264       TextureMailbox(mailbox, GL_TEXTURE_2D, sync_point), callback.Pass());
2265
2266   EXPECT_EQ(0u, release_sync_point);
2267   EXPECT_FALSE(lost_resource);
2268   EXPECT_EQ(NULL, main_thread_task_runner);
2269
2270   resource_provider_->DidLoseOutputSurface();
2271   resource_provider_.reset();
2272
2273   EXPECT_LE(sync_point, release_sync_point);
2274   EXPECT_TRUE(lost_resource);
2275   EXPECT_EQ(main_thread_task_runner_.get(), main_thread_task_runner);
2276 }
2277
2278 TEST_P(ResourceProviderTest, ScopedSampler) {
2279   // Sampling is only supported for GL textures.
2280   if (GetParam() != ResourceProvider::GLTexture)
2281     return;
2282
2283   scoped_ptr<TextureStateTrackingContext> context_owned(
2284       new TextureStateTrackingContext);
2285   TextureStateTrackingContext* context = context_owned.get();
2286
2287   FakeOutputSurfaceClient output_surface_client;
2288   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
2289       context_owned.PassAs<TestWebGraphicsContext3D>()));
2290   CHECK(output_surface->BindToClient(&output_surface_client));
2291
2292   scoped_ptr<ResourceProvider> resource_provider(
2293       ResourceProvider::Create(output_surface.get(),
2294                                shared_bitmap_manager_.get(),
2295                                NULL,
2296                                0,
2297                                false,
2298                                1,
2299                                false));
2300
2301   gfx::Size size(1, 1);
2302   ResourceFormat format = RGBA_8888;
2303   int texture_id = 1;
2304
2305   ResourceProvider::ResourceId id = resource_provider->CreateResource(
2306       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
2307
2308   // Check that the texture gets created with the right sampler settings.
2309   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id))
2310       .Times(2);  // Once to create and once to allocate.
2311   EXPECT_CALL(*context,
2312               texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
2313   EXPECT_CALL(*context,
2314               texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
2315   EXPECT_CALL(
2316       *context,
2317       texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
2318   EXPECT_CALL(
2319       *context,
2320       texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
2321   EXPECT_CALL(*context,
2322               texParameteri(GL_TEXTURE_2D,
2323                             GL_TEXTURE_POOL_CHROMIUM,
2324                             GL_TEXTURE_POOL_UNMANAGED_CHROMIUM));
2325
2326   resource_provider->AllocateForTesting(id);
2327   Mock::VerifyAndClearExpectations(context);
2328
2329   // Creating a sampler with the default filter should not change any texture
2330   // parameters.
2331   {
2332     EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id));
2333     ResourceProvider::ScopedSamplerGL sampler(
2334         resource_provider.get(), id, GL_TEXTURE_2D, GL_LINEAR);
2335     Mock::VerifyAndClearExpectations(context);
2336   }
2337
2338   // Using a different filter should be reflected in the texture parameters.
2339   {
2340     EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id));
2341     EXPECT_CALL(
2342         *context,
2343         texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST));
2344     EXPECT_CALL(
2345         *context,
2346         texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST));
2347     ResourceProvider::ScopedSamplerGL sampler(
2348         resource_provider.get(), id, GL_TEXTURE_2D, GL_NEAREST);
2349     Mock::VerifyAndClearExpectations(context);
2350   }
2351
2352   // Test resetting to the default filter.
2353   {
2354     EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id));
2355     EXPECT_CALL(*context,
2356                 texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
2357     EXPECT_CALL(*context,
2358                 texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
2359     ResourceProvider::ScopedSamplerGL sampler(
2360         resource_provider.get(), id, GL_TEXTURE_2D, GL_LINEAR);
2361     Mock::VerifyAndClearExpectations(context);
2362   }
2363 }
2364
2365 TEST_P(ResourceProviderTest, ManagedResource) {
2366   // Sampling is only supported for GL textures.
2367   if (GetParam() != ResourceProvider::GLTexture)
2368     return;
2369
2370   scoped_ptr<TextureStateTrackingContext> context_owned(
2371       new TextureStateTrackingContext);
2372   TextureStateTrackingContext* context = context_owned.get();
2373
2374   FakeOutputSurfaceClient output_surface_client;
2375   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
2376       context_owned.PassAs<TestWebGraphicsContext3D>()));
2377   CHECK(output_surface->BindToClient(&output_surface_client));
2378
2379   scoped_ptr<ResourceProvider> resource_provider(
2380       ResourceProvider::Create(output_surface.get(),
2381                                shared_bitmap_manager_.get(),
2382                                NULL,
2383                                0,
2384                                false,
2385                                1,
2386                                false));
2387
2388   gfx::Size size(1, 1);
2389   ResourceFormat format = RGBA_8888;
2390   int texture_id = 1;
2391
2392   // Check that the texture gets created with the right sampler settings.
2393   ResourceProvider::ResourceId id = resource_provider->CreateManagedResource(
2394       size,
2395       GL_TEXTURE_2D,
2396       GL_CLAMP_TO_EDGE,
2397       ResourceProvider::TextureHintImmutable,
2398       format);
2399   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id));
2400   EXPECT_CALL(*context,
2401               texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
2402   EXPECT_CALL(*context,
2403               texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
2404   EXPECT_CALL(
2405       *context,
2406       texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
2407   EXPECT_CALL(
2408       *context,
2409       texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
2410   EXPECT_CALL(*context,
2411               texParameteri(GL_TEXTURE_2D,
2412                             GL_TEXTURE_POOL_CHROMIUM,
2413                             GL_TEXTURE_POOL_MANAGED_CHROMIUM));
2414   resource_provider->CreateForTesting(id);
2415   EXPECT_NE(0u, id);
2416
2417   Mock::VerifyAndClearExpectations(context);
2418 }
2419
2420 TEST_P(ResourceProviderTest, TextureWrapMode) {
2421   // Sampling is only supported for GL textures.
2422   if (GetParam() != ResourceProvider::GLTexture)
2423     return;
2424
2425   scoped_ptr<TextureStateTrackingContext> context_owned(
2426       new TextureStateTrackingContext);
2427   TextureStateTrackingContext* context = context_owned.get();
2428
2429   FakeOutputSurfaceClient output_surface_client;
2430   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
2431       context_owned.PassAs<TestWebGraphicsContext3D>()));
2432   CHECK(output_surface->BindToClient(&output_surface_client));
2433
2434   scoped_ptr<ResourceProvider> resource_provider(
2435       ResourceProvider::Create(output_surface.get(),
2436                                shared_bitmap_manager_.get(),
2437                                NULL,
2438                                0,
2439                                false,
2440                                1,
2441                                false));
2442
2443   gfx::Size size(1, 1);
2444   ResourceFormat format = RGBA_8888;
2445   GLenum texture_pool = GL_TEXTURE_POOL_UNMANAGED_CHROMIUM;
2446
2447   for (int texture_id = 1; texture_id <= 2; ++texture_id) {
2448     GLint wrap_mode = texture_id == 1 ? GL_CLAMP_TO_EDGE : GL_REPEAT;
2449     // Check that the texture gets created with the right sampler settings.
2450     ResourceProvider::ResourceId id = resource_provider->CreateGLTexture(
2451         size,
2452         GL_TEXTURE_2D,
2453         texture_pool,
2454         wrap_mode,
2455         ResourceProvider::TextureHintImmutable,
2456         format);
2457     EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id));
2458     EXPECT_CALL(*context,
2459                 texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
2460     EXPECT_CALL(*context,
2461                 texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
2462     EXPECT_CALL(*context,
2463                 texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrap_mode));
2464     EXPECT_CALL(*context,
2465                 texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrap_mode));
2466     EXPECT_CALL(*context,
2467                 texParameteri(GL_TEXTURE_2D,
2468                               GL_TEXTURE_POOL_CHROMIUM,
2469                               GL_TEXTURE_POOL_UNMANAGED_CHROMIUM));
2470     resource_provider->CreateForTesting(id);
2471     EXPECT_NE(0u, id);
2472
2473     Mock::VerifyAndClearExpectations(context);
2474   }
2475 }
2476
2477 TEST_P(ResourceProviderTest, TextureHint) {
2478   // Sampling is only supported for GL textures.
2479   if (GetParam() != ResourceProvider::GLTexture)
2480     return;
2481
2482   scoped_ptr<TextureStateTrackingContext> context_owned(
2483       new TextureStateTrackingContext);
2484   TextureStateTrackingContext* context = context_owned.get();
2485   context->set_support_texture_storage(true);
2486   context->set_support_texture_usage(true);
2487
2488   FakeOutputSurfaceClient output_surface_client;
2489   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
2490       context_owned.PassAs<TestWebGraphicsContext3D>()));
2491   CHECK(output_surface->BindToClient(&output_surface_client));
2492
2493   scoped_ptr<ResourceProvider> resource_provider(
2494       ResourceProvider::Create(output_surface.get(),
2495                                shared_bitmap_manager_.get(),
2496                                NULL,
2497                                0,
2498                                false,
2499                                1,
2500                                false));
2501
2502   gfx::Size size(1, 1);
2503   ResourceFormat format = RGBA_8888;
2504   GLenum texture_pool = GL_TEXTURE_POOL_UNMANAGED_CHROMIUM;
2505
2506   const ResourceProvider::TextureHint hints[4] = {
2507       ResourceProvider::TextureHintDefault,
2508       ResourceProvider::TextureHintImmutable,
2509       ResourceProvider::TextureHintFramebuffer,
2510       ResourceProvider::TextureHintImmutableFramebuffer,
2511   };
2512   for (GLuint texture_id = 1; texture_id <= arraysize(hints); ++texture_id) {
2513     // Check that the texture gets created with the right sampler settings.
2514     ResourceProvider::ResourceId id =
2515         resource_provider->CreateGLTexture(size,
2516                                            GL_TEXTURE_2D,
2517                                            texture_pool,
2518                                            GL_CLAMP_TO_EDGE,
2519                                            hints[texture_id - 1],
2520                                            format);
2521     EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id));
2522     EXPECT_CALL(*context,
2523                 texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
2524     EXPECT_CALL(*context,
2525                 texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
2526     EXPECT_CALL(
2527         *context,
2528         texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
2529     EXPECT_CALL(
2530         *context,
2531         texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
2532     EXPECT_CALL(*context,
2533                 texParameteri(GL_TEXTURE_2D,
2534                               GL_TEXTURE_POOL_CHROMIUM,
2535                               GL_TEXTURE_POOL_UNMANAGED_CHROMIUM));
2536     // Check only TextureHintFramebuffer set GL_TEXTURE_USAGE_ANGLE.
2537     bool is_framebuffer_hint =
2538         hints[texture_id - 1] & ResourceProvider::TextureHintFramebuffer;
2539     EXPECT_CALL(*context,
2540                 texParameteri(GL_TEXTURE_2D,
2541                               GL_TEXTURE_USAGE_ANGLE,
2542                               GL_FRAMEBUFFER_ATTACHMENT_ANGLE))
2543         .Times(is_framebuffer_hint ? 1 : 0);
2544     resource_provider->CreateForTesting(id);
2545     EXPECT_NE(0u, id);
2546
2547     Mock::VerifyAndClearExpectations(context);
2548   }
2549 }
2550
2551 TEST_P(ResourceProviderTest, TextureMailbox_SharedMemory) {
2552   if (GetParam() != ResourceProvider::Bitmap)
2553     return;
2554
2555   gfx::Size size(64, 64);
2556   const uint32_t kBadBeef = 0xbadbeef;
2557   scoped_ptr<base::SharedMemory> shared_memory(
2558       CreateAndFillSharedMemory(size, kBadBeef));
2559
2560   FakeOutputSurfaceClient output_surface_client;
2561   scoped_ptr<OutputSurface> output_surface(
2562       FakeOutputSurface::CreateSoftware(make_scoped_ptr(
2563           new SoftwareOutputDevice)));
2564   CHECK(output_surface->BindToClient(&output_surface_client));
2565
2566   scoped_ptr<ResourceProvider> resource_provider(
2567       ResourceProvider::Create(output_surface.get(),
2568                                shared_bitmap_manager_.get(),
2569                                main_thread_task_runner_.get(),
2570                                0,
2571                                false,
2572                                1,
2573                                false));
2574
2575   uint32 release_sync_point = 0;
2576   bool lost_resource = false;
2577   BlockingTaskRunner* main_thread_task_runner = NULL;
2578   scoped_ptr<SingleReleaseCallbackImpl> callback =
2579       SingleReleaseCallbackImpl::Create(base::Bind(&ReleaseCallback,
2580                                                    &release_sync_point,
2581                                                    &lost_resource,
2582                                                    &main_thread_task_runner));
2583   TextureMailbox mailbox(shared_memory.get(), size);
2584
2585   ResourceProvider::ResourceId id =
2586       resource_provider->CreateResourceFromTextureMailbox(
2587           mailbox, callback.Pass());
2588   EXPECT_NE(0u, id);
2589
2590   {
2591     ResourceProvider::ScopedReadLockSoftware lock(resource_provider.get(), id);
2592     const SkBitmap* sk_bitmap = lock.sk_bitmap();
2593     EXPECT_EQ(sk_bitmap->width(), size.width());
2594     EXPECT_EQ(sk_bitmap->height(), size.height());
2595     EXPECT_EQ(*sk_bitmap->getAddr32(16, 16), kBadBeef);
2596   }
2597
2598   resource_provider->DeleteResource(id);
2599   EXPECT_EQ(0u, release_sync_point);
2600   EXPECT_FALSE(lost_resource);
2601   EXPECT_EQ(main_thread_task_runner_.get(), main_thread_task_runner);
2602 }
2603
2604 TEST_P(ResourceProviderTest, TextureMailbox_GLTexture2D) {
2605   // Mailboxing is only supported for GL textures.
2606   if (GetParam() != ResourceProvider::GLTexture)
2607     return;
2608
2609   scoped_ptr<TextureStateTrackingContext> context_owned(
2610       new TextureStateTrackingContext);
2611   TextureStateTrackingContext* context = context_owned.get();
2612
2613   FakeOutputSurfaceClient output_surface_client;
2614   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
2615       context_owned.PassAs<TestWebGraphicsContext3D>()));
2616   CHECK(output_surface->BindToClient(&output_surface_client));
2617
2618   scoped_ptr<ResourceProvider> resource_provider(
2619       ResourceProvider::Create(output_surface.get(),
2620                                shared_bitmap_manager_.get(),
2621                                main_thread_task_runner_.get(),
2622                                0,
2623                                false,
2624                                1,
2625                                false));
2626
2627   unsigned texture_id = 1;
2628   uint32 sync_point = 30;
2629   unsigned target = GL_TEXTURE_2D;
2630
2631   EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
2632   EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
2633   EXPECT_CALL(*context, insertSyncPoint()).Times(0);
2634   EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
2635   EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).Times(0);
2636
2637   gpu::Mailbox gpu_mailbox;
2638   memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
2639   uint32 release_sync_point = 0;
2640   bool lost_resource = false;
2641   BlockingTaskRunner* main_thread_task_runner = NULL;
2642   scoped_ptr<SingleReleaseCallbackImpl> callback =
2643       SingleReleaseCallbackImpl::Create(base::Bind(&ReleaseCallback,
2644                                                    &release_sync_point,
2645                                                    &lost_resource,
2646                                                    &main_thread_task_runner));
2647
2648   TextureMailbox mailbox(gpu_mailbox, target, sync_point);
2649
2650   ResourceProvider::ResourceId id =
2651       resource_provider->CreateResourceFromTextureMailbox(
2652           mailbox, callback.Pass());
2653   EXPECT_NE(0u, id);
2654
2655   Mock::VerifyAndClearExpectations(context);
2656
2657   {
2658     // Mailbox sync point WaitSyncPoint before using the texture.
2659     EXPECT_CALL(*context, waitSyncPoint(sync_point));
2660     resource_provider->WaitSyncPointIfNeeded(id);
2661     Mock::VerifyAndClearExpectations(context);
2662
2663     // Using the texture does a consume of the mailbox.
2664     EXPECT_CALL(*context, bindTexture(target, texture_id));
2665     EXPECT_CALL(*context, consumeTextureCHROMIUM(target, _));
2666
2667     EXPECT_CALL(*context, insertSyncPoint()).Times(0);
2668     EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
2669
2670     ResourceProvider::ScopedReadLockGL lock(resource_provider.get(), id);
2671     Mock::VerifyAndClearExpectations(context);
2672
2673     // When done with it, a sync point should be inserted, but no produce is
2674     // necessary.
2675     EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
2676     EXPECT_CALL(*context, insertSyncPoint());
2677     EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
2678
2679     EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
2680     EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).Times(0);
2681   }
2682
2683   resource_provider->DeleteResource(id);
2684   EXPECT_EQ(0u, release_sync_point);
2685   EXPECT_FALSE(lost_resource);
2686   EXPECT_EQ(main_thread_task_runner_.get(), main_thread_task_runner);
2687 }
2688
2689 TEST_P(ResourceProviderTest, TextureMailbox_GLTextureExternalOES) {
2690   // Mailboxing is only supported for GL textures.
2691   if (GetParam() != ResourceProvider::GLTexture)
2692     return;
2693
2694   scoped_ptr<TextureStateTrackingContext> context_owned(
2695       new TextureStateTrackingContext);
2696   TextureStateTrackingContext* context = context_owned.get();
2697
2698   FakeOutputSurfaceClient output_surface_client;
2699   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
2700       context_owned.PassAs<TestWebGraphicsContext3D>()));
2701   CHECK(output_surface->BindToClient(&output_surface_client));
2702
2703   scoped_ptr<ResourceProvider> resource_provider(
2704       ResourceProvider::Create(output_surface.get(),
2705                                shared_bitmap_manager_.get(),
2706                                NULL,
2707                                0,
2708                                false,
2709                                1,
2710                                false));
2711
2712   unsigned texture_id = 1;
2713   uint32 sync_point = 30;
2714   unsigned target = GL_TEXTURE_EXTERNAL_OES;
2715
2716   EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
2717   EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
2718   EXPECT_CALL(*context, insertSyncPoint()).Times(0);
2719   EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
2720   EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).Times(0);
2721
2722   gpu::Mailbox gpu_mailbox;
2723   memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
2724   scoped_ptr<SingleReleaseCallbackImpl> callback =
2725       SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback));
2726
2727   TextureMailbox mailbox(gpu_mailbox, target, sync_point);
2728
2729   ResourceProvider::ResourceId id =
2730       resource_provider->CreateResourceFromTextureMailbox(
2731           mailbox, callback.Pass());
2732   EXPECT_NE(0u, id);
2733
2734   Mock::VerifyAndClearExpectations(context);
2735
2736   {
2737     // Mailbox sync point WaitSyncPoint before using the texture.
2738     EXPECT_CALL(*context, waitSyncPoint(sync_point));
2739     resource_provider->WaitSyncPointIfNeeded(id);
2740     Mock::VerifyAndClearExpectations(context);
2741
2742     // Using the texture does a consume of the mailbox.
2743     EXPECT_CALL(*context, bindTexture(target, texture_id));
2744     EXPECT_CALL(*context, consumeTextureCHROMIUM(target, _));
2745
2746     EXPECT_CALL(*context, insertSyncPoint()).Times(0);
2747     EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
2748
2749     ResourceProvider::ScopedReadLockGL lock(resource_provider.get(), id);
2750     Mock::VerifyAndClearExpectations(context);
2751
2752     // When done with it, a sync point should be inserted, but no produce is
2753     // necessary.
2754     EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
2755     EXPECT_CALL(*context, insertSyncPoint());
2756     EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
2757
2758     EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
2759     EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).Times(0);
2760   }
2761 }
2762
2763 TEST_P(ResourceProviderTest,
2764        TextureMailbox_WaitSyncPointIfNeeded_WithSyncPoint) {
2765   // Mailboxing is only supported for GL textures.
2766   if (GetParam() != ResourceProvider::GLTexture)
2767     return;
2768
2769   scoped_ptr<TextureStateTrackingContext> context_owned(
2770       new TextureStateTrackingContext);
2771   TextureStateTrackingContext* context = context_owned.get();
2772
2773   FakeOutputSurfaceClient output_surface_client;
2774   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
2775       context_owned.PassAs<TestWebGraphicsContext3D>()));
2776   CHECK(output_surface->BindToClient(&output_surface_client));
2777
2778   scoped_ptr<ResourceProvider> resource_provider(
2779       ResourceProvider::Create(output_surface.get(),
2780                                shared_bitmap_manager_.get(),
2781                                NULL,
2782                                0,
2783                                false,
2784                                1,
2785                                false));
2786
2787   uint32 sync_point = 30;
2788   unsigned target = GL_TEXTURE_2D;
2789
2790   EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
2791   EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
2792   EXPECT_CALL(*context, insertSyncPoint()).Times(0);
2793   EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
2794   EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).Times(0);
2795
2796   gpu::Mailbox gpu_mailbox;
2797   memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
2798   scoped_ptr<SingleReleaseCallbackImpl> callback =
2799       SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback));
2800
2801   TextureMailbox mailbox(gpu_mailbox, target, sync_point);
2802
2803   ResourceProvider::ResourceId id =
2804       resource_provider->CreateResourceFromTextureMailbox(mailbox,
2805                                                           callback.Pass());
2806   EXPECT_NE(0u, id);
2807
2808   Mock::VerifyAndClearExpectations(context);
2809
2810   {
2811     // First call to WaitSyncPointIfNeeded should call waitSyncPoint.
2812     EXPECT_CALL(*context, waitSyncPoint(sync_point));
2813     resource_provider->WaitSyncPointIfNeeded(id);
2814     Mock::VerifyAndClearExpectations(context);
2815
2816     // Subsequent calls to WaitSyncPointIfNeeded shouldn't call waitSyncPoint.
2817     EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
2818     resource_provider->WaitSyncPointIfNeeded(id);
2819     Mock::VerifyAndClearExpectations(context);
2820   }
2821 }
2822
2823 TEST_P(ResourceProviderTest, TextureMailbox_WaitSyncPointIfNeeded_NoSyncPoint) {
2824   // Mailboxing is only supported for GL textures.
2825   if (GetParam() != ResourceProvider::GLTexture)
2826     return;
2827
2828   scoped_ptr<TextureStateTrackingContext> context_owned(
2829       new TextureStateTrackingContext);
2830   TextureStateTrackingContext* context = context_owned.get();
2831
2832   FakeOutputSurfaceClient output_surface_client;
2833   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
2834       context_owned.PassAs<TestWebGraphicsContext3D>()));
2835   CHECK(output_surface->BindToClient(&output_surface_client));
2836
2837   scoped_ptr<ResourceProvider> resource_provider(
2838       ResourceProvider::Create(output_surface.get(),
2839                                shared_bitmap_manager_.get(),
2840                                NULL,
2841                                0,
2842                                false,
2843                                1,
2844                                false));
2845
2846   uint32 sync_point = 0;
2847   unsigned target = GL_TEXTURE_2D;
2848
2849   EXPECT_CALL(*context, bindTexture(_, _)).Times(0);
2850   EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
2851   EXPECT_CALL(*context, insertSyncPoint()).Times(0);
2852   EXPECT_CALL(*context, produceTextureCHROMIUM(_, _)).Times(0);
2853   EXPECT_CALL(*context, consumeTextureCHROMIUM(_, _)).Times(0);
2854
2855   gpu::Mailbox gpu_mailbox;
2856   memcpy(gpu_mailbox.name, "Hello world", strlen("Hello world") + 1);
2857   scoped_ptr<SingleReleaseCallbackImpl> callback =
2858       SingleReleaseCallbackImpl::Create(base::Bind(&EmptyReleaseCallback));
2859
2860   TextureMailbox mailbox(gpu_mailbox, target, sync_point);
2861
2862   ResourceProvider::ResourceId id =
2863       resource_provider->CreateResourceFromTextureMailbox(mailbox,
2864                                                           callback.Pass());
2865   EXPECT_NE(0u, id);
2866
2867   Mock::VerifyAndClearExpectations(context);
2868
2869   {
2870     // WaitSyncPointIfNeeded with sync_point == 0 shouldn't call waitSyncPoint.
2871     EXPECT_CALL(*context, waitSyncPoint(_)).Times(0);
2872     resource_provider->WaitSyncPointIfNeeded(id);
2873     Mock::VerifyAndClearExpectations(context);
2874   }
2875 }
2876
2877 class AllocationTrackingContext3D : public TestWebGraphicsContext3D {
2878  public:
2879   MOCK_METHOD0(NextTextureId, GLuint());
2880   MOCK_METHOD1(RetireTextureId, void(GLuint id));
2881   MOCK_METHOD2(bindTexture, void(GLenum target, GLuint texture));
2882   MOCK_METHOD5(texStorage2DEXT,
2883                void(GLenum target,
2884                     GLint levels,
2885                     GLuint internalformat,
2886                     GLint width,
2887                     GLint height));
2888   MOCK_METHOD9(texImage2D,
2889                void(GLenum target,
2890                     GLint level,
2891                     GLenum internalformat,
2892                     GLsizei width,
2893                     GLsizei height,
2894                     GLint border,
2895                     GLenum format,
2896                     GLenum type,
2897                     const void* pixels));
2898   MOCK_METHOD9(texSubImage2D,
2899                void(GLenum target,
2900                     GLint level,
2901                     GLint xoffset,
2902                     GLint yoffset,
2903                     GLsizei width,
2904                     GLsizei height,
2905                     GLenum format,
2906                     GLenum type,
2907                     const void* pixels));
2908   MOCK_METHOD9(asyncTexImage2DCHROMIUM,
2909                void(GLenum target,
2910                     GLint level,
2911                     GLenum internalformat,
2912                     GLsizei width,
2913                     GLsizei height,
2914                     GLint border,
2915                     GLenum format,
2916                     GLenum type,
2917                     const void* pixels));
2918   MOCK_METHOD9(asyncTexSubImage2DCHROMIUM,
2919                void(GLenum target,
2920                     GLint level,
2921                     GLint xoffset,
2922                     GLint yoffset,
2923                     GLsizei width,
2924                     GLsizei height,
2925                     GLenum format,
2926                     GLenum type,
2927                     const void* pixels));
2928   MOCK_METHOD8(compressedTexImage2D,
2929                void(GLenum target,
2930                     GLint level,
2931                     GLenum internalformat,
2932                     GLsizei width,
2933                     GLsizei height,
2934                     GLint border,
2935                     GLsizei image_size,
2936                     const void* data));
2937   MOCK_METHOD1(waitAsyncTexImage2DCHROMIUM, void(GLenum));
2938   MOCK_METHOD4(createImageCHROMIUM, GLuint(GLsizei, GLsizei, GLenum, GLenum));
2939   MOCK_METHOD1(destroyImageCHROMIUM, void(GLuint));
2940   MOCK_METHOD1(mapImageCHROMIUM, void*(GLuint));
2941   MOCK_METHOD3(getImageParameterivCHROMIUM, void(GLuint, GLenum, GLint*));
2942   MOCK_METHOD1(unmapImageCHROMIUM, void(GLuint));
2943   MOCK_METHOD2(bindTexImage2DCHROMIUM, void(GLenum, GLint));
2944   MOCK_METHOD2(releaseTexImage2DCHROMIUM, void(GLenum, GLint));
2945
2946   // We're mocking bindTexture, so we override
2947   // TestWebGraphicsContext3D::texParameteri to avoid assertions related to the
2948   // currently bound texture.
2949   virtual void texParameteri(GLenum target, GLenum pname, GLint param) {}
2950 };
2951
2952 TEST_P(ResourceProviderTest, TextureAllocation) {
2953   // Only for GL textures.
2954   if (GetParam() != ResourceProvider::GLTexture)
2955     return;
2956   scoped_ptr<AllocationTrackingContext3D> context_owned(
2957       new StrictMock<AllocationTrackingContext3D>);
2958   AllocationTrackingContext3D* context = context_owned.get();
2959
2960   FakeOutputSurfaceClient output_surface_client;
2961   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
2962       context_owned.PassAs<TestWebGraphicsContext3D>()));
2963   CHECK(output_surface->BindToClient(&output_surface_client));
2964
2965   scoped_ptr<ResourceProvider> resource_provider(
2966       ResourceProvider::Create(output_surface.get(),
2967                                shared_bitmap_manager_.get(),
2968                                NULL,
2969                                0,
2970                                false,
2971                                1,
2972                                false));
2973
2974   gfx::Size size(2, 2);
2975   gfx::Vector2d offset(0, 0);
2976   gfx::Rect rect(0, 0, 2, 2);
2977   ResourceFormat format = RGBA_8888;
2978   ResourceProvider::ResourceId id = 0;
2979   uint8_t pixels[16] = { 0 };
2980   int texture_id = 123;
2981
2982   // Lazy allocation. Don't allocate when creating the resource.
2983   id = resource_provider->CreateResource(
2984       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
2985
2986   EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
2987   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(1);
2988   resource_provider->CreateForTesting(id);
2989
2990   EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
2991   resource_provider->DeleteResource(id);
2992
2993   Mock::VerifyAndClearExpectations(context);
2994
2995   // Do allocate when we set the pixels.
2996   id = resource_provider->CreateResource(
2997       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
2998
2999   EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
3000   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(3);
3001   EXPECT_CALL(*context, texImage2D(_, _, _, 2, 2, _, _, _, _)).Times(1);
3002   EXPECT_CALL(*context, texSubImage2D(_, _, _, _, 2, 2, _, _, _)).Times(1);
3003   resource_provider->SetPixels(id, pixels, rect, rect, offset);
3004
3005   EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
3006   resource_provider->DeleteResource(id);
3007
3008   Mock::VerifyAndClearExpectations(context);
3009
3010   // Same for async version.
3011   id = resource_provider->CreateResource(
3012       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
3013   resource_provider->AcquirePixelBuffer(id);
3014
3015   EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
3016   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
3017   EXPECT_CALL(*context, asyncTexImage2DCHROMIUM(_, _, _, 2, 2, _, _, _, _))
3018       .Times(1);
3019   resource_provider->BeginSetPixels(id);
3020   ASSERT_TRUE(resource_provider->DidSetPixelsComplete(id));
3021
3022   resource_provider->ReleasePixelBuffer(id);
3023
3024   EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
3025   resource_provider->DeleteResource(id);
3026
3027   Mock::VerifyAndClearExpectations(context);
3028 }
3029
3030 TEST_P(ResourceProviderTest, TextureAllocationHint) {
3031   // Only for GL textures.
3032   if (GetParam() != ResourceProvider::GLTexture)
3033     return;
3034   scoped_ptr<AllocationTrackingContext3D> context_owned(
3035       new StrictMock<AllocationTrackingContext3D>);
3036   AllocationTrackingContext3D* context = context_owned.get();
3037   context->set_support_texture_storage(true);
3038   context->set_support_texture_usage(true);
3039
3040   FakeOutputSurfaceClient output_surface_client;
3041   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
3042       context_owned.PassAs<TestWebGraphicsContext3D>()));
3043   CHECK(output_surface->BindToClient(&output_surface_client));
3044
3045   scoped_ptr<ResourceProvider> resource_provider(
3046       ResourceProvider::Create(output_surface.get(),
3047                                shared_bitmap_manager_.get(),
3048                                NULL,
3049                                0,
3050                                false,
3051                                1,
3052                                false));
3053
3054   gfx::Size size(2, 2);
3055
3056   const ResourceFormat formats[2] = {RGBA_8888, BGRA_8888};
3057   const ResourceProvider::TextureHint hints[4] = {
3058       ResourceProvider::TextureHintDefault,
3059       ResourceProvider::TextureHintImmutable,
3060       ResourceProvider::TextureHintFramebuffer,
3061       ResourceProvider::TextureHintImmutableFramebuffer,
3062   };
3063   for (size_t i = 0; i < arraysize(formats); ++i) {
3064     for (GLuint texture_id = 1; texture_id <= arraysize(hints); ++texture_id) {
3065       // Lazy allocation. Don't allocate when creating the resource.
3066       ResourceProvider::ResourceId id = resource_provider->CreateResource(
3067           size, GL_CLAMP_TO_EDGE, hints[texture_id - 1], formats[i]);
3068
3069       EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
3070       EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
3071       bool is_immutable_hint =
3072           hints[texture_id - 1] & ResourceProvider::TextureHintImmutable;
3073       bool support_immutable_texture =
3074           is_immutable_hint && formats[i] == RGBA_8888;
3075       EXPECT_CALL(*context, texStorage2DEXT(_, _, _, 2, 2))
3076           .Times(support_immutable_texture ? 1 : 0);
3077       EXPECT_CALL(*context, texImage2D(_, _, _, 2, 2, _, _, _, _))
3078           .Times(support_immutable_texture ? 0 : 1);
3079       resource_provider->AllocateForTesting(id);
3080
3081       EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
3082       resource_provider->DeleteResource(id);
3083
3084       Mock::VerifyAndClearExpectations(context);
3085     }
3086   }
3087 }
3088
3089 TEST_P(ResourceProviderTest, TextureAllocationHint_BGRA) {
3090   // Only for GL textures.
3091   if (GetParam() != ResourceProvider::GLTexture)
3092     return;
3093   scoped_ptr<AllocationTrackingContext3D> context_owned(
3094       new StrictMock<AllocationTrackingContext3D>);
3095   AllocationTrackingContext3D* context = context_owned.get();
3096   context->set_support_texture_format_bgra8888(true);
3097   context->set_support_texture_storage(true);
3098   context->set_support_texture_usage(true);
3099
3100   FakeOutputSurfaceClient output_surface_client;
3101   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
3102       context_owned.PassAs<TestWebGraphicsContext3D>()));
3103   CHECK(output_surface->BindToClient(&output_surface_client));
3104
3105   scoped_ptr<ResourceProvider> resource_provider(
3106       ResourceProvider::Create(output_surface.get(),
3107                                shared_bitmap_manager_.get(),
3108                                NULL,
3109                                0,
3110                                false,
3111                                1,
3112                                false));
3113
3114   gfx::Size size(2, 2);
3115   const ResourceFormat formats[2] = {RGBA_8888, BGRA_8888};
3116
3117   const ResourceProvider::TextureHint hints[4] = {
3118       ResourceProvider::TextureHintDefault,
3119       ResourceProvider::TextureHintImmutable,
3120       ResourceProvider::TextureHintFramebuffer,
3121       ResourceProvider::TextureHintImmutableFramebuffer,
3122   };
3123   for (size_t i = 0; i < arraysize(formats); ++i) {
3124     for (GLuint texture_id = 1; texture_id <= arraysize(hints); ++texture_id) {
3125       // Lazy allocation. Don't allocate when creating the resource.
3126       ResourceProvider::ResourceId id = resource_provider->CreateResource(
3127           size, GL_CLAMP_TO_EDGE, hints[texture_id - 1], formats[i]);
3128
3129       EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
3130       EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
3131       bool is_immutable_hint =
3132           hints[texture_id - 1] & ResourceProvider::TextureHintImmutable;
3133       EXPECT_CALL(*context, texStorage2DEXT(_, _, _, 2, 2))
3134           .Times(is_immutable_hint ? 1 : 0);
3135       EXPECT_CALL(*context, texImage2D(_, _, _, 2, 2, _, _, _, _))
3136           .Times(is_immutable_hint ? 0 : 1);
3137       resource_provider->AllocateForTesting(id);
3138
3139       EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
3140       resource_provider->DeleteResource(id);
3141
3142       Mock::VerifyAndClearExpectations(context);
3143     }
3144   }
3145 }
3146
3147 TEST_P(ResourceProviderTest, PixelBuffer_GLTexture) {
3148   if (GetParam() != ResourceProvider::GLTexture)
3149     return;
3150   scoped_ptr<AllocationTrackingContext3D> context_owned(
3151       new StrictMock<AllocationTrackingContext3D>);
3152   AllocationTrackingContext3D* context = context_owned.get();
3153
3154   FakeOutputSurfaceClient output_surface_client;
3155   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
3156       context_owned.PassAs<TestWebGraphicsContext3D>()));
3157   CHECK(output_surface->BindToClient(&output_surface_client));
3158
3159   gfx::Size size(2, 2);
3160   ResourceFormat format = RGBA_8888;
3161   ResourceProvider::ResourceId id = 0;
3162   int texture_id = 123;
3163
3164   scoped_ptr<ResourceProvider> resource_provider(
3165       ResourceProvider::Create(output_surface.get(),
3166                                shared_bitmap_manager_.get(),
3167                                NULL,
3168                                0,
3169                                false,
3170                                1,
3171                                false));
3172
3173   id = resource_provider->CreateResource(
3174       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
3175   resource_provider->AcquirePixelBuffer(id);
3176
3177   EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
3178   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
3179   EXPECT_CALL(*context, asyncTexImage2DCHROMIUM(_, _, _, 2, 2, _, _, _, _))
3180       .Times(1);
3181   resource_provider->BeginSetPixels(id);
3182
3183   EXPECT_TRUE(resource_provider->DidSetPixelsComplete(id));
3184
3185   resource_provider->ReleasePixelBuffer(id);
3186
3187   EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
3188   resource_provider->DeleteResource(id);
3189
3190   Mock::VerifyAndClearExpectations(context);
3191 }
3192
3193 TEST_P(ResourceProviderTest, ForcingAsyncUploadToComplete) {
3194   // Only for GL textures.
3195   if (GetParam() != ResourceProvider::GLTexture)
3196     return;
3197   scoped_ptr<AllocationTrackingContext3D> context_owned(
3198       new StrictMock<AllocationTrackingContext3D>);
3199   AllocationTrackingContext3D* context = context_owned.get();
3200
3201   FakeOutputSurfaceClient output_surface_client;
3202   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
3203       context_owned.PassAs<TestWebGraphicsContext3D>()));
3204   CHECK(output_surface->BindToClient(&output_surface_client));
3205
3206   gfx::Size size(2, 2);
3207   ResourceFormat format = RGBA_8888;
3208   ResourceProvider::ResourceId id = 0;
3209   int texture_id = 123;
3210
3211   scoped_ptr<ResourceProvider> resource_provider(
3212       ResourceProvider::Create(output_surface.get(),
3213                                shared_bitmap_manager_.get(),
3214                                NULL,
3215                                0,
3216                                false,
3217                                1,
3218                                false));
3219
3220   id = resource_provider->CreateResource(
3221       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
3222   resource_provider->AcquirePixelBuffer(id);
3223
3224   EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
3225   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
3226   EXPECT_CALL(*context, asyncTexImage2DCHROMIUM(_, _, _, 2, 2, _, _, _, _))
3227       .Times(1);
3228   resource_provider->BeginSetPixels(id);
3229
3230   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(1);
3231   EXPECT_CALL(*context, waitAsyncTexImage2DCHROMIUM(GL_TEXTURE_2D)).Times(1);
3232   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, 0)).Times(1);
3233   resource_provider->ForceSetPixelsToComplete(id);
3234
3235   resource_provider->ReleasePixelBuffer(id);
3236
3237   EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
3238   resource_provider->DeleteResource(id);
3239
3240   Mock::VerifyAndClearExpectations(context);
3241 }
3242
3243 TEST_P(ResourceProviderTest, PixelBufferLostContext) {
3244   scoped_ptr<AllocationTrackingContext3D> context_owned(
3245       new NiceMock<AllocationTrackingContext3D>);
3246   AllocationTrackingContext3D* context = context_owned.get();
3247
3248   FakeOutputSurfaceClient output_surface_client;
3249   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
3250       context_owned.PassAs<TestWebGraphicsContext3D>()));
3251   CHECK(output_surface->BindToClient(&output_surface_client));
3252
3253   gfx::Size size(2, 2);
3254   ResourceFormat format = RGBA_8888;
3255   ResourceProvider::ResourceId id = 0;
3256   int texture_id = 123;
3257
3258   scoped_ptr<ResourceProvider> resource_provider(
3259       ResourceProvider::Create(output_surface.get(),
3260                                shared_bitmap_manager_.get(),
3261                                NULL,
3262                                0,
3263                                false,
3264                                1,
3265                                false));
3266
3267   EXPECT_CALL(*context, NextTextureId()).WillRepeatedly(Return(texture_id));
3268
3269   id = resource_provider->CreateResource(
3270       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
3271   context->loseContextCHROMIUM(GL_GUILTY_CONTEXT_RESET_ARB,
3272                                GL_INNOCENT_CONTEXT_RESET_ARB);
3273
3274   resource_provider->AcquirePixelBuffer(id);
3275   int stride;
3276   void* buffer = resource_provider->MapPixelBuffer(id, &stride);
3277   EXPECT_FALSE(buffer);
3278   resource_provider->UnmapPixelBuffer(id);
3279   Mock::VerifyAndClearExpectations(context);
3280 }
3281
3282 TEST_P(ResourceProviderTest, Image_GLTexture) {
3283   // Only for GL textures.
3284   if (GetParam() != ResourceProvider::GLTexture)
3285     return;
3286   scoped_ptr<AllocationTrackingContext3D> context_owned(
3287       new StrictMock<AllocationTrackingContext3D>);
3288   AllocationTrackingContext3D* context = context_owned.get();
3289
3290   FakeOutputSurfaceClient output_surface_client;
3291   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
3292       context_owned.PassAs<TestWebGraphicsContext3D>()));
3293   CHECK(output_surface->BindToClient(&output_surface_client));
3294
3295   const int kWidth = 2;
3296   const int kHeight = 2;
3297   gfx::Size size(kWidth, kHeight);
3298   ResourceFormat format = RGBA_8888;
3299   ResourceProvider::ResourceId id = 0;
3300   const unsigned kTextureId = 123u;
3301   const unsigned kImageId = 234u;
3302
3303   scoped_ptr<ResourceProvider> resource_provider(
3304       ResourceProvider::Create(output_surface.get(),
3305                                shared_bitmap_manager_.get(),
3306                                NULL,
3307                                0,
3308                                false,
3309                                1,
3310                                false));
3311
3312   id = resource_provider->CreateResource(
3313       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
3314
3315   const int kStride = 4;
3316   void* dummy_mapped_buffer_address = NULL;
3317   EXPECT_CALL(
3318       *context,
3319       createImageCHROMIUM(kWidth, kHeight, GL_RGBA8_OES, GL_IMAGE_MAP_CHROMIUM))
3320       .WillOnce(Return(kImageId))
3321       .RetiresOnSaturation();
3322   resource_provider->AcquireImage(id);
3323
3324   EXPECT_CALL(*context, getImageParameterivCHROMIUM(kImageId,
3325                                                     GL_IMAGE_ROWBYTES_CHROMIUM,
3326                                                     _))
3327       .WillOnce(SetArgPointee<2>(kStride))
3328       .RetiresOnSaturation();
3329   EXPECT_CALL(*context, mapImageCHROMIUM(kImageId))
3330       .WillOnce(Return(dummy_mapped_buffer_address))
3331       .RetiresOnSaturation();
3332   int stride;
3333   resource_provider->MapImage(id, &stride);
3334
3335   EXPECT_CALL(*context, unmapImageCHROMIUM(kImageId))
3336       .Times(1)
3337       .RetiresOnSaturation();
3338   resource_provider->UnmapImage(id);
3339
3340   EXPECT_CALL(*context, NextTextureId())
3341       .WillOnce(Return(kTextureId))
3342       .RetiresOnSaturation();
3343   // Once in CreateTextureId and once in BindForSampling
3344   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, kTextureId)).Times(2)
3345       .RetiresOnSaturation();
3346   EXPECT_CALL(*context, bindTexImage2DCHROMIUM(GL_TEXTURE_2D, kImageId))
3347       .Times(1)
3348       .RetiresOnSaturation();
3349   {
3350     ResourceProvider::ScopedSamplerGL lock_gl(
3351         resource_provider.get(), id, GL_TEXTURE_2D, GL_LINEAR);
3352     EXPECT_EQ(kTextureId, lock_gl.texture_id());
3353   }
3354
3355   EXPECT_CALL(
3356       *context,
3357       getImageParameterivCHROMIUM(kImageId, GL_IMAGE_ROWBYTES_CHROMIUM, _))
3358       .WillOnce(SetArgPointee<2>(kStride))
3359       .RetiresOnSaturation();
3360   EXPECT_CALL(*context, mapImageCHROMIUM(kImageId))
3361       .WillOnce(Return(dummy_mapped_buffer_address))
3362       .RetiresOnSaturation();
3363   resource_provider->MapImage(id, &stride);
3364
3365   EXPECT_CALL(*context, unmapImageCHROMIUM(kImageId))
3366       .Times(1)
3367       .RetiresOnSaturation();
3368   resource_provider->UnmapImage(id);
3369
3370   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, kTextureId)).Times(1)
3371       .RetiresOnSaturation();
3372   EXPECT_CALL(*context, releaseTexImage2DCHROMIUM(GL_TEXTURE_2D, kImageId))
3373       .Times(1)
3374       .RetiresOnSaturation();
3375   EXPECT_CALL(*context, bindTexImage2DCHROMIUM(GL_TEXTURE_2D, kImageId))
3376       .Times(1)
3377       .RetiresOnSaturation();
3378   EXPECT_CALL(*context, RetireTextureId(kTextureId))
3379       .Times(1)
3380       .RetiresOnSaturation();
3381   {
3382     ResourceProvider::ScopedSamplerGL lock_gl(
3383         resource_provider.get(), id, GL_TEXTURE_2D, GL_LINEAR);
3384     EXPECT_EQ(kTextureId, lock_gl.texture_id());
3385   }
3386
3387   EXPECT_CALL(*context, destroyImageCHROMIUM(kImageId))
3388       .Times(1)
3389       .RetiresOnSaturation();
3390 }
3391
3392 TEST_P(ResourceProviderTest, CopyResource_GLTexture) {
3393   if (GetParam() != ResourceProvider::GLTexture)
3394     return;
3395   scoped_ptr<AllocationTrackingContext3D> context_owned(
3396       new StrictMock<AllocationTrackingContext3D>);
3397   AllocationTrackingContext3D* context = context_owned.get();
3398   context_owned->set_support_sync_query(true);
3399
3400   FakeOutputSurfaceClient output_surface_client;
3401   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
3402       context_owned.PassAs<TestWebGraphicsContext3D>()));
3403   ASSERT_TRUE(output_surface->BindToClient(&output_surface_client));
3404
3405   const int kWidth = 2;
3406   const int kHeight = 2;
3407   gfx::Size size(kWidth, kHeight);
3408   ResourceFormat format = RGBA_8888;
3409   ResourceProvider::ResourceId source_id = 0;
3410   ResourceProvider::ResourceId dest_id = 0;
3411   const unsigned kSourceTextureId = 123u;
3412   const unsigned kDestTextureId = 321u;
3413   const unsigned kImageId = 234u;
3414
3415   scoped_ptr<ResourceProvider> resource_provider(
3416       ResourceProvider::Create(output_surface.get(),
3417                                shared_bitmap_manager_.get(),
3418                                NULL,
3419                                0,
3420                                false,
3421                                1,
3422                                false));
3423
3424   source_id = resource_provider->CreateResource(
3425       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
3426
3427   const int kStride = 4;
3428   void* dummy_mapped_buffer_address = NULL;
3429   EXPECT_CALL(
3430       *context,
3431       createImageCHROMIUM(kWidth, kHeight, GL_RGBA8_OES, GL_IMAGE_MAP_CHROMIUM))
3432       .WillOnce(Return(kImageId))
3433       .RetiresOnSaturation();
3434   EXPECT_CALL(
3435       *context,
3436       getImageParameterivCHROMIUM(kImageId, GL_IMAGE_ROWBYTES_CHROMIUM, _))
3437       .WillOnce(SetArgPointee<2>(kStride))
3438       .RetiresOnSaturation();
3439   EXPECT_CALL(*context, mapImageCHROMIUM(kImageId))
3440       .WillOnce(Return(dummy_mapped_buffer_address))
3441       .RetiresOnSaturation();
3442   resource_provider->AcquireImage(source_id);
3443   int stride;
3444   resource_provider->MapImage(source_id, &stride);
3445   EXPECT_CALL(*context, unmapImageCHROMIUM(kImageId))
3446       .Times(1)
3447       .RetiresOnSaturation();
3448   resource_provider->UnmapImage(source_id);
3449   Mock::VerifyAndClearExpectations(context);
3450
3451   dest_id = resource_provider->CreateResource(
3452       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
3453
3454   EXPECT_CALL(*context, NextTextureId())
3455       .WillOnce(Return(kDestTextureId))
3456       .RetiresOnSaturation();
3457   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, kDestTextureId))
3458       .Times(1)
3459       .RetiresOnSaturation();
3460   EXPECT_CALL(*context, NextTextureId())
3461       .WillOnce(Return(kSourceTextureId))
3462       .RetiresOnSaturation();
3463   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, kSourceTextureId))
3464       .Times(2)
3465       .RetiresOnSaturation();
3466   EXPECT_CALL(*context, bindTexImage2DCHROMIUM(GL_TEXTURE_2D, kImageId))
3467       .Times(1)
3468       .RetiresOnSaturation();
3469   resource_provider->CopyResource(source_id, dest_id);
3470   Mock::VerifyAndClearExpectations(context);
3471
3472   EXPECT_CALL(*context, destroyImageCHROMIUM(kImageId))
3473       .Times(1)
3474       .RetiresOnSaturation();
3475   EXPECT_CALL(*context, RetireTextureId(kSourceTextureId))
3476       .Times(1)
3477       .RetiresOnSaturation();
3478   EXPECT_CALL(*context, RetireTextureId(kDestTextureId))
3479       .Times(1)
3480       .RetiresOnSaturation();
3481   resource_provider->DeleteResource(source_id);
3482   resource_provider->DeleteResource(dest_id);
3483 }
3484
3485 void InitializeGLAndCheck(ContextSharedData* shared_data,
3486                           ResourceProvider* resource_provider,
3487                           FakeOutputSurface* output_surface) {
3488   scoped_ptr<ResourceProviderContext> context_owned =
3489       ResourceProviderContext::Create(shared_data);
3490   ResourceProviderContext* context = context_owned.get();
3491
3492   scoped_refptr<TestContextProvider> context_provider =
3493       TestContextProvider::Create(
3494           context_owned.PassAs<TestWebGraphicsContext3D>());
3495   output_surface->InitializeAndSetContext3d(context_provider);
3496   resource_provider->InitializeGL();
3497
3498   CheckCreateResource(ResourceProvider::GLTexture, resource_provider, context);
3499 }
3500
3501 TEST(ResourceProviderTest, BasicInitializeGLSoftware) {
3502   scoped_ptr<ContextSharedData> shared_data = ContextSharedData::Create();
3503   bool delegated_rendering = false;
3504   scoped_ptr<FakeOutputSurface> output_surface(
3505       FakeOutputSurface::CreateDeferredGL(
3506           scoped_ptr<SoftwareOutputDevice>(new SoftwareOutputDevice),
3507           delegated_rendering));
3508   FakeOutputSurfaceClient client(output_surface.get());
3509   EXPECT_TRUE(output_surface->BindToClient(&client));
3510   scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
3511       new TestSharedBitmapManager());
3512   scoped_ptr<ResourceProvider> resource_provider(
3513       ResourceProvider::Create(output_surface.get(),
3514                                shared_bitmap_manager.get(),
3515                                NULL,
3516                                0,
3517                                false,
3518                                1,
3519                                false));
3520
3521   CheckCreateResource(ResourceProvider::Bitmap, resource_provider.get(), NULL);
3522
3523   InitializeGLAndCheck(shared_data.get(),
3524                        resource_provider.get(),
3525                        output_surface.get());
3526
3527   resource_provider->InitializeSoftware();
3528   output_surface->ReleaseGL();
3529   CheckCreateResource(ResourceProvider::Bitmap, resource_provider.get(), NULL);
3530
3531   InitializeGLAndCheck(shared_data.get(),
3532                        resource_provider.get(),
3533                        output_surface.get());
3534 }
3535
3536 TEST_P(ResourceProviderTest, CompressedTextureETC1Allocate) {
3537   if (GetParam() != ResourceProvider::GLTexture)
3538     return;
3539
3540   scoped_ptr<AllocationTrackingContext3D> context_owned(
3541       new AllocationTrackingContext3D);
3542   AllocationTrackingContext3D* context = context_owned.get();
3543   context_owned->set_support_compressed_texture_etc1(true);
3544
3545   FakeOutputSurfaceClient output_surface_client;
3546   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
3547       context_owned.PassAs<TestWebGraphicsContext3D>()));
3548   CHECK(output_surface->BindToClient(&output_surface_client));
3549
3550   gfx::Size size(4, 4);
3551   scoped_ptr<ResourceProvider> resource_provider(
3552       ResourceProvider::Create(output_surface.get(),
3553                                shared_bitmap_manager_.get(),
3554                                NULL,
3555                                0,
3556                                false,
3557                                1,
3558                                false));
3559   int texture_id = 123;
3560
3561   ResourceProvider::ResourceId id = resource_provider->CreateResource(
3562       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, ETC1);
3563   EXPECT_NE(0u, id);
3564   EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
3565   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(2);
3566   resource_provider->AllocateForTesting(id);
3567
3568   EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
3569   resource_provider->DeleteResource(id);
3570 }
3571
3572 TEST_P(ResourceProviderTest, CompressedTextureETC1SetPixels) {
3573   if (GetParam() != ResourceProvider::GLTexture)
3574     return;
3575
3576   scoped_ptr<AllocationTrackingContext3D> context_owned(
3577       new AllocationTrackingContext3D);
3578   AllocationTrackingContext3D* context = context_owned.get();
3579   context_owned->set_support_compressed_texture_etc1(true);
3580
3581   FakeOutputSurfaceClient output_surface_client;
3582   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
3583       context_owned.PassAs<TestWebGraphicsContext3D>()));
3584   CHECK(output_surface->BindToClient(&output_surface_client));
3585
3586   gfx::Size size(4, 4);
3587   scoped_ptr<ResourceProvider> resource_provider(
3588       ResourceProvider::Create(output_surface.get(),
3589                                shared_bitmap_manager_.get(),
3590                                NULL,
3591                                0,
3592                                false,
3593                                1,
3594                                false));
3595   int texture_id = 123;
3596   uint8_t pixels[8];
3597
3598   ResourceProvider::ResourceId id = resource_provider->CreateResource(
3599       size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, ETC1);
3600   EXPECT_NE(0u, id);
3601   EXPECT_CALL(*context, NextTextureId()).WillOnce(Return(texture_id));
3602   EXPECT_CALL(*context, bindTexture(GL_TEXTURE_2D, texture_id)).Times(3);
3603   EXPECT_CALL(*context,
3604               compressedTexImage2D(
3605                   _, 0, _, size.width(), size.height(), _, _, _)).Times(1);
3606   resource_provider->SetPixels(
3607       id, pixels, gfx::Rect(size), gfx::Rect(size), gfx::Vector2d(0, 0));
3608
3609   EXPECT_CALL(*context, RetireTextureId(texture_id)).Times(1);
3610   resource_provider->DeleteResource(id);
3611 }
3612
3613 INSTANTIATE_TEST_CASE_P(
3614     ResourceProviderTests,
3615     ResourceProviderTest,
3616     ::testing::Values(ResourceProvider::GLTexture, ResourceProvider::Bitmap));
3617
3618 class TextureIdAllocationTrackingContext : public TestWebGraphicsContext3D {
3619  public:
3620   virtual GLuint NextTextureId() OVERRIDE {
3621     base::AutoLock lock(namespace_->lock);
3622     return namespace_->next_texture_id++;
3623   }
3624   virtual void RetireTextureId(GLuint) OVERRIDE {}
3625   GLuint PeekTextureId() {
3626     base::AutoLock lock(namespace_->lock);
3627     return namespace_->next_texture_id;
3628   }
3629 };
3630
3631 TEST(ResourceProviderTest, TextureAllocationChunkSize) {
3632   scoped_ptr<TextureIdAllocationTrackingContext> context_owned(
3633       new TextureIdAllocationTrackingContext);
3634   TextureIdAllocationTrackingContext* context = context_owned.get();
3635
3636   FakeOutputSurfaceClient output_surface_client;
3637   scoped_ptr<OutputSurface> output_surface(FakeOutputSurface::Create3d(
3638       context_owned.PassAs<TestWebGraphicsContext3D>()));
3639   CHECK(output_surface->BindToClient(&output_surface_client));
3640   scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
3641       new TestSharedBitmapManager());
3642
3643   gfx::Size size(1, 1);
3644   ResourceFormat format = RGBA_8888;
3645
3646   {
3647     size_t kTextureAllocationChunkSize = 1;
3648     scoped_ptr<ResourceProvider> resource_provider(
3649         ResourceProvider::Create(output_surface.get(),
3650                                  shared_bitmap_manager.get(),
3651                                  NULL,
3652                                  0,
3653                                  false,
3654                                  kTextureAllocationChunkSize,
3655                                  false));
3656
3657     ResourceProvider::ResourceId id = resource_provider->CreateResource(
3658         size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
3659     resource_provider->AllocateForTesting(id);
3660     Mock::VerifyAndClearExpectations(context);
3661
3662     DCHECK_EQ(2u, context->PeekTextureId());
3663     resource_provider->DeleteResource(id);
3664   }
3665
3666   {
3667     size_t kTextureAllocationChunkSize = 8;
3668     scoped_ptr<ResourceProvider> resource_provider(
3669         ResourceProvider::Create(output_surface.get(),
3670                                  shared_bitmap_manager.get(),
3671                                  NULL,
3672                                  0,
3673                                  false,
3674                                  kTextureAllocationChunkSize,
3675                                  false));
3676
3677     ResourceProvider::ResourceId id = resource_provider->CreateResource(
3678         size, GL_CLAMP_TO_EDGE, ResourceProvider::TextureHintImmutable, format);
3679     resource_provider->AllocateForTesting(id);
3680     Mock::VerifyAndClearExpectations(context);
3681
3682     DCHECK_EQ(10u, context->PeekTextureId());
3683     resource_provider->DeleteResource(id);
3684   }
3685 }
3686
3687 }  // namespace
3688 }  // namespace cc