ContextProvider in OutputSurface

cc/resources/raster_worker_pool_unittest.cc

 // Copyright 2013 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/raster_worker_pool.h"
 
 #include <vector>
 
+#include "cc/debug/test_web_graphics_context_3d.h"
 #include "cc/resources/image_raster_worker_pool.h"
 #include "cc/resources/picture_pile.h"
 #include "cc/resources/picture_pile_impl.h"
 #include "cc/resources/pixel_buffer_raster_worker_pool.h"
 #include "cc/resources/resource_provider.h"
 #include "cc/resources/scoped_resource.h"
 #include "cc/test/fake_output_surface.h"
+#include "cc/test/fake_output_surface_client.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 
 class TestRasterWorkerPoolTaskImpl : public internal::RasterWorkerPoolTask {
  public:
   typedef base::Callback<void(const PicturePileImpl::Analysis& analysis,
                               bool was_canceled,
                               bool did_raster)> Reply;
 
@@ skipping 22 matching lines @@
   const Reply reply_;
   bool did_raster_;
 
   DISALLOW_COPY_AND_ASSIGN(TestRasterWorkerPoolTaskImpl);
 };
 
 class RasterWorkerPoolTest : public testing::Test,
                              public RasterWorkerPoolClient  {
  public:
   RasterWorkerPoolTest()
-      : output_surface_(FakeOutputSurface::Create3d()),
-        resource_provider_(
-            ResourceProvider::Create(output_surface_.get(), 0)),
+      : context_provider_(TestContextProvider::Create()),
         check_interval_milliseconds_(1),
         timeout_seconds_(5),
         timed_out_(false) {
+    output_surface_ = FakeOutputSurface::Create3d(context_provider_).Pass();
+    CHECK(output_surface_->BindToClient(&output_surface_client_));
+
+    resource_provider_ = ResourceProvider::Create(output_surface_.get(),
+                                                  0).Pass();
   }
   virtual ~RasterWorkerPoolTest() {
     resource_provider_.reset();
   }
 
   // Overridden from testing::Test:
   virtual void TearDown() OVERRIDE {
     if (!raster_worker_pool_)
       return;
     raster_worker_pool_->Shutdown();
@@ skipping 109 matching lines @@
     raster_worker_pool_->CheckForCompletedTasks();
     ScheduleCheckForCompletedTasks();
   }
 
   void OnTimeout() {
     timed_out_ = true;
     base::MessageLoop::current()->Quit();
   }
 
  protected:
+  scoped_refptr<TestContextProvider> context_provider_;
+  FakeOutputSurfaceClient output_surface_client_;
   scoped_ptr<FakeOutputSurface> output_surface_;
   scoped_ptr<ResourceProvider> resource_provider_;
   scoped_ptr<RasterWorkerPool> raster_worker_pool_;
   base::CancelableClosure check_;
   int check_interval_milliseconds_;
   base::CancelableClosure timeout_;
   int timeout_seconds_;
   bool timed_out_;
   std::vector<RasterWorkerPool::RasterTask> tasks_;
 };
@@ skipping 49 matching lines @@
                                unsigned id,
                                const PicturePileImpl::Analysis& analysis,
                                bool was_canceled,
                                bool did_raster) OVERRIDE {
     EXPECT_FALSE(did_raster);
     EndTest();
   }
 
   // Overridden from RasterWorkerPoolTest:
   virtual void BeginTest() OVERRIDE {
-    TestWebGraphicsContext3D* context3d =
-        static_cast<TestWebGraphicsContext3D*>(output_surface_->context3d());
+    TestWebGraphicsContext3D* context3d = context_provider_->TestContext3d();
     context3d->set_times_map_image_chromium_succeeds(0);
     context3d->set_times_map_buffer_chromium_succeeds(0);
     AppendTask(0u);
     ScheduleTasks();
   }
 
   virtual void AfterTest() OVERRIDE {
     ASSERT_EQ(1u, tasks_.size());
     tasks_.clear();
   }
 };
 
 PIXEL_BUFFER_AND_IMAGE_TEST_F(RasterWorkerPoolTestFailedMapResource);
 
 }  // namespace
 
 }  // namespace cc