cc::OutputSurfaceClient::InitializeForGL

cc/trees/layer_tree_host_impl_unittest.cc

 // Copyright 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "cc/trees/layer_tree_host_impl.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 46 matching lines @@
 namespace cc {
 namespace {
 
 class LayerTreeHostImplTest : public testing::Test,
                               public LayerTreeHostImplClient {
  public:
   LayerTreeHostImplTest()
       : proxy_(scoped_ptr<Thread>(NULL)),
         always_impl_thread_(&proxy_),
         always_main_thread_blocked_(&proxy_),
+        did_try_initialize_renderer_(false),
         on_can_draw_state_changed_called_(false),
         has_pending_tree_(false),
         did_request_commit_(false),
         did_request_redraw_(false),
         did_upload_visible_tile_(false),
         reduce_memory_result_(true) {
     media::InitializeMediaLibraryForTesting();
   }
 
   virtual void OverrideSettings(LayerTreeSettings* settings) {}
 
   virtual void SetUp() OVERRIDE {
     LayerTreeSettings settings;
     settings.minimum_occlusion_tracking_size = gfx::Size();
     OverrideSettings(&settings);
 
     host_impl_ = LayerTreeHostImpl::Create(settings,
                                            this,
                                            &proxy_,
                                            &stats_instrumentation_);
     host_impl_->InitializeRenderer(CreateOutputSurface());
     host_impl_->SetViewportSize(gfx::Size(10, 10));
   }
 
   virtual void TearDown() OVERRIDE {}
 
+  virtual void DidTryInitializeRendererOnImplThread(
+      bool success,
+      scoped_refptr<ContextProvider> offscreen_context_provider) OVERRIDE {
+    did_try_initialize_renderer_ = true;
+  }
   virtual void DidLoseOutputSurfaceOnImplThread() OVERRIDE {}
   virtual void OnSwapBuffersCompleteOnImplThread() OVERRIDE {}
   virtual void OnVSyncParametersChanged(base::TimeTicks timebase,
                                         base::TimeDelta interval) OVERRIDE {}
   virtual void BeginFrameOnImplThread(base::TimeTicks frame_time)
       OVERRIDE {}
   virtual void OnCanDrawStateChanged(bool can_draw) OVERRIDE {
     on_can_draw_state_changed_called_ = true;
   }
   virtual void OnHasPendingTreeStateChanged(bool has_pending_tree) OVERRIDE {
@@ skipping 165 matching lines @@
     host_impl_->PrepareToDraw(&frame_data, gfx::Rect());
     host_impl_->DidDrawAllLayers(frame_data);
   }
 
   FakeProxy proxy_;
   DebugScopedSetImplThread always_impl_thread_;
   DebugScopedSetMainThreadBlocked always_main_thread_blocked_;
 
   scoped_ptr<LayerTreeHostImpl> host_impl_;
   FakeRenderingStatsInstrumentation stats_instrumentation_;
+  bool did_try_initialize_renderer_;
   bool on_can_draw_state_changed_called_;
   bool has_pending_tree_;
   bool did_request_commit_;
   bool did_request_redraw_;
   bool did_upload_visible_tile_;
   bool reduce_memory_result_;
 };
 
 class TestWebGraphicsContext3DMakeCurrentFails
     : public TestWebGraphicsContext3D {
@@ skipping 5491 matching lines @@
   }
 
   int frames_began_, frames_ended_;
 };
 
 TEST_F(LayerTreeHostImplTest, ForcedDrawToSoftwareDeviceBasicRender) {
   SetupScrollAndContentsLayers(gfx::Size(100, 100));
   host_impl_->SetViewportSize(gfx::Size(50, 50));
   CountingSoftwareDevice* software_device = new CountingSoftwareDevice();
   FakeOutputSurface* output_surface = FakeOutputSurface::CreateDeferredGL(
+      scoped_ptr<WebKit::WebGraphicsContext3D>(),
       scoped_ptr<SoftwareOutputDevice>(software_device)).release();
   host_impl_->InitializeRenderer(scoped_ptr<OutputSurface>(output_surface));
 
   output_surface->set_forced_draw_to_software_device(true);
   EXPECT_TRUE(output_surface->ForcedDrawToSoftwareDevice());
 
   EXPECT_EQ(0, software_device->frames_began_);
   EXPECT_EQ(0, software_device->frames_ended_);
 
   DrawFrame();
 
   EXPECT_EQ(1, software_device->frames_began_);
   EXPECT_EQ(1, software_device->frames_ended_);
 
   // Call other API methods that are likely to hit NULL pointer in this mode.
   EXPECT_TRUE(host_impl_->AsValue());
   EXPECT_TRUE(host_impl_->ActivationStateAsValue());
 }
 
 TEST_F(LayerTreeHostImplTest,
        ForcedDrawToSoftwareDeviceSkipsUnsupportedLayers) {
   FakeOutputSurface* output_surface = FakeOutputSurface::CreateDeferredGL(
+      scoped_ptr<WebKit::WebGraphicsContext3D>(),
       scoped_ptr<SoftwareOutputDevice>(new CountingSoftwareDevice())).release();
   host_impl_->InitializeRenderer(
       scoped_ptr<OutputSurface>(output_surface));
 
   output_surface->set_forced_draw_to_software_device(true);
   EXPECT_TRUE(output_surface->ForcedDrawToSoftwareDevice());
 
   // SolidColorLayerImpl will be drawn.
   scoped_ptr<SolidColorLayerImpl> root_layer =
       SolidColorLayerImpl::Create(host_impl_->active_tree(), 1);
@@ skipping 10 matching lines @@
 
   LayerTreeHostImpl::FrameData frame;
   EXPECT_TRUE(host_impl_->PrepareToDraw(&frame, gfx::Rect()));
   host_impl_->DrawLayers(&frame, base::TimeTicks::Now());
   host_impl_->DidDrawAllLayers(frame);
 
   EXPECT_EQ(1u, frame.will_draw_layers.size());
   EXPECT_EQ(host_impl_->active_tree()->root_layer(), frame.will_draw_layers[0]);
 }
 
+TEST_F(LayerTreeHostImplTest, DeferredInitializeSmoke) {
+  host_impl_->InitializeRenderer(
+      scoped_ptr<OutputSurface>(FakeOutputSurface::CreateDeferredGL(
+          scoped_ptr<WebKit::WebGraphicsContext3D>(
+              TestWebGraphicsContext3D::Create(
+                  WebKit::WebGraphicsContext3D::Attributes())),
+          scoped_ptr<SoftwareOutputDevice>(new CountingSoftwareDevice()))));
+
+  // Add two layers.
+  scoped_ptr<SolidColorLayerImpl> root_layer =
+      SolidColorLayerImpl::Create(host_impl_->active_tree(), 1);
+  FakeVideoFrameProvider provider;
+  scoped_ptr<VideoLayerImpl> video_layer =
+      VideoLayerImpl::Create(host_impl_->active_tree(), 2, &provider);
+  video_layer->SetBounds(gfx::Size(10, 10));
+  video_layer->SetContentBounds(gfx::Size(10, 10));
+  video_layer->SetDrawsContent(true);
+  root_layer->AddChild(video_layer.PassAs<LayerImpl>());
+  SetupRootLayerImpl(root_layer.PassAs<LayerImpl>());
+
+  // Software draw.
+  DrawFrame();
+
+  // DeferredInitialize and hardware draw.
+  EXPECT_FALSE(did_try_initialize_renderer_);
+  host_impl_->DeferredInitialize(scoped_refptr<ContextProvider>());
+  EXPECT_TRUE(did_try_initialize_renderer_);
+
+  // Defer intialized GL draw.
+  DrawFrame();
+}
+
 }  // namespace
 }  // namespace cc