Update from chromium a8e7c94b1b79a0948d05a1fcfff53391d22ce37a

cc/output/overlay_unittest.cc

 // Copyright 2014 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/base/scoped_ptr_vector.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/output/output_surface.h"
 #include "cc/output/output_surface_client.h"
 #include "cc/output/overlay_candidate_validator.h"
 #include "cc/output/overlay_processor.h"
@@ skipping 226 matching lines @@
 TEST(OverlayTest, OverlaysProcessorHasStrategy) {
   scoped_refptr<TestContextProvider> provider = TestContextProvider::Create();
   OverlayOutputSurface output_surface(provider);
   FakeOutputSurfaceClient client;
   EXPECT_TRUE(output_surface.BindToClient(&client));
   output_surface.InitWithSingleOverlayValidator();
   EXPECT_TRUE(output_surface.overlay_candidate_validator() != NULL);
 
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager(
       new TestSharedBitmapManager());
-  scoped_ptr<ResourceProvider> resource_provider(
-      ResourceProvider::Create(&output_surface,
-                               shared_bitmap_manager.get(),
-                               NULL,
-                               NULL,
-                               0,
-                               false,
-                               1,
-                               false));
+  scoped_ptr<ResourceProvider> resource_provider(ResourceProvider::Create(
+      &output_surface, shared_bitmap_manager.get(), NULL, NULL, 0, false, 1));
 
   scoped_ptr<DefaultOverlayProcessor> overlay_processor(
       new DefaultOverlayProcessor(&output_surface, resource_provider.get()));
   overlay_processor->Initialize();
   EXPECT_GE(1U, overlay_processor->GetStrategyCount());
 }
 
 class SingleOverlayOnTopTest : public testing::Test {
  protected:
   virtual void SetUp() {
     provider_ = TestContextProvider::Create();
     output_surface_.reset(new OverlayOutputSurface(provider_));
     EXPECT_TRUE(output_surface_->BindToClient(&client_));
     output_surface_->InitWithSingleOverlayValidator();
     EXPECT_TRUE(output_surface_->overlay_candidate_validator() != NULL);
 
     shared_bitmap_manager_.reset(new TestSharedBitmapManager());
     resource_provider_ = ResourceProvider::Create(output_surface_.get(),
                                                   shared_bitmap_manager_.get(),
                                                   NULL,
                                                   NULL,
                                                   0,
                                                   false,
-                                                  1,
-                                                  false);
+                                                  1);
 
     overlay_processor_.reset(new SingleOverlayProcessor(
         output_surface_.get(), resource_provider_.get()));
     overlay_processor_->Initialize();
   }
 
   scoped_refptr<TestContextProvider> provider_;
   scoped_ptr<OverlayOutputSurface> output_surface_;
   FakeOutputSurfaceClient client_;
   scoped_ptr<SharedBitmapManager> shared_bitmap_manager_;
@@ skipping 290 matching lines @@
                     const gfx::RectF& uv_rect));
 };
 
 class GLRendererWithOverlaysTest : public testing::Test {
  protected:
   GLRendererWithOverlaysTest() {
     provider_ = TestContextProvider::Create();
     output_surface_.reset(new OverlayOutputSurface(provider_));
     CHECK(output_surface_->BindToClient(&output_surface_client_));
     resource_provider_ = ResourceProvider::Create(
-        output_surface_.get(), NULL, NULL, NULL, 0, false, 1, false);
+        output_surface_.get(), NULL, NULL, NULL, 0, false, 1);
 
     provider_->support()->SetScheduleOverlayPlaneCallback(base::Bind(
         &MockOverlayScheduler::Schedule, base::Unretained(&scheduler_)));
   }
 
   void Init(bool use_validator) {
     if (use_validator)
       output_surface_->InitWithSingleOverlayValidator();
 
     renderer_ =
@@ skipping 195 matching lines @@
   renderer_->set_expect_overlays(false);
   renderer_->FinishDrawingFrame(&frame3);
   EXPECT_TRUE(resource_provider_->InUseByConsumer(resource1));
   SwapBuffers();
   EXPECT_FALSE(resource_provider_->InUseByConsumer(resource1));
   Mock::VerifyAndClearExpectations(&scheduler_);
 }
 
 }  // namespace
 }  // namespace cc