Pass correct texture hint for GPU raster

cc/resources/resource_pool_unittest.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/resources/resource_pool.h"
 
 #include <stddef.h>
 
 #include "base/run_loop.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 10 matching lines @@
  public:
   void SetUp() override {
     context_provider_ = TestContextProvider::Create();
     context_provider_->BindToCurrentThread();
     shared_bitmap_manager_.reset(new TestSharedBitmapManager);
     resource_provider_ = FakeResourceProvider::Create(
         context_provider_.get(), shared_bitmap_manager_.get());
     task_runner_ = base::ThreadTaskRunnerHandle::Get();
     resource_pool_ =
         ResourcePool::Create(resource_provider_.get(), task_runner_.get(),
+                             ResourceProvider::TEXTURE_HINT_IMMUTABLE,
                              ResourcePool::kDefaultExpirationDelay);
   }
 
  protected:
   scoped_refptr<TestContextProvider> context_provider_;
   std::unique_ptr<SharedBitmapManager> shared_bitmap_manager_;
   std::unique_ptr<ResourceProvider> resource_provider_;
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
   std::unique_ptr<ResourcePool> resource_pool_;
 };
@@ skipping 110 matching lines @@
   resource_pool_->ReleaseResource(resource);
   resource_pool_->CheckBusyResources();
   EXPECT_EQ(0u, resource_provider_->num_resources());
 }
 
 TEST_F(ResourcePoolTest, BusyResourcesEventuallyFreed) {
   // Set a quick resource expiration delay so that this test doesn't take long
   // to run.
   resource_pool_ =
       ResourcePool::Create(resource_provider_.get(), task_runner_.get(),
+                           ResourceProvider::TEXTURE_HINT_IMMUTABLE,
                            base::TimeDelta::FromMilliseconds(10));
 
   // Limits high enough to not be hit by this test.
   size_t bytes_limit = 10 * 1024 * 1024;
   size_t count_limit = 100;
   resource_pool_->SetResourceUsageLimits(bytes_limit, count_limit);
 
   gfx::Size size(100, 100);
   ResourceFormat format = RGBA_8888;
   gfx::ColorSpace color_space;
@@ skipping 20 matching lines @@
   EXPECT_EQ(0u, resource_provider_->num_resources());
   EXPECT_EQ(0u, resource_pool_->GetTotalMemoryUsageForTesting());
   EXPECT_EQ(0u, resource_pool_->memory_usage_bytes());
 }
 
 TEST_F(ResourcePoolTest, UnusedResourcesEventuallyFreed) {
   // Set a quick resource expiration delay so that this test doesn't take long
   // to run.
   resource_pool_ =
       ResourcePool::Create(resource_provider_.get(), task_runner_.get(),
+                           ResourceProvider::TEXTURE_HINT_IMMUTABLE,
                            base::TimeDelta::FromMilliseconds(100));
 
   // Limits high enough to not be hit by this test.
   size_t bytes_limit = 10 * 1024 * 1024;
   size_t count_limit = 100;
   resource_pool_->SetResourceUsageLimits(bytes_limit, count_limit);
 
   gfx::Size size(100, 100);
   ResourceFormat format = RGBA_8888;
   gfx::ColorSpace color_space;
@@ skipping 149 matching lines @@
   resource_pool_->ReleaseResource(resource);
   EXPECT_EQ(1u, resource_pool_->GetTotalResourceCountForTesting());
   EXPECT_EQ(1u, resource_pool_->GetBusyResourceCountForTesting());
 
   // Suspending should now free the busy resource.
   resource_pool_->OnMemoryStateChange(base::MemoryState::SUSPENDED);
   EXPECT_EQ(0u, resource_pool_->GetTotalResourceCountForTesting());
   EXPECT_EQ(0u, resource_pool_->GetBusyResourceCountForTesting());
 }
 
+TEST_F(ResourcePoolTest, TextureHintRespected) {
+  gfx::Size size(100, 100);
+  ResourceFormat format = RGBA_8888;
+  gfx::ColorSpace color_space;
+
+  resource_pool_ =
+      ResourcePool::Create(resource_provider_.get(), task_runner_.get(),
+                           ResourceProvider::TEXTURE_HINT_IMMUTABLE,
+                           base::TimeDelta::FromMilliseconds(100));
+  Resource* resource =
+      resource_pool_->AcquireResource(size, format, color_space);
+  EXPECT_TRUE(resource_provider_->IsImmutable(resource->id()));
+  resource_pool_->ReleaseResource(resource);
+
+  resource_pool_ =
+      ResourcePool::Create(resource_provider_.get(), task_runner_.get(),
+                           ResourceProvider::TEXTURE_HINT_DEFAULT,
+                           base::TimeDelta::FromMilliseconds(100));
+  resource = resource_pool_->AcquireResource(size, format, color_space);
+  EXPECT_FALSE(resource_provider_->IsImmutable(resource->id()));
+  resource_pool_->ReleaseResource(resource);
+}
+
 }  // namespace cc