Register surface namespace in BlimpUiContextFactory

ui/compositor/test/in_process_context_factory.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 "ui/compositor/test/in_process_context_factory.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 67 matching lines @@
 
  private:
   base::WeakPtrFactory<DirectOutputSurface> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DirectOutputSurface);
 };
 
 }  // namespace
 
 InProcessContextFactory::InProcessContextFactory(
-    bool context_factory_for_test,
-    cc::SurfaceManager* surface_manager)
+    bool context_factory_for_test)
     : next_surface_id_namespace_(1u),
       use_test_surface_(true),
       context_factory_for_test_(context_factory_for_test),
-      surface_manager_(surface_manager) {
+      surface_manager_(new cc::SurfaceManager()) {
   DCHECK_NE(gfx::GetGLImplementation(), gfx::kGLImplementationNone)
       << "If running tests, ensure that main() is calling "
       << "gfx::GLSurfaceTestSupport::InitializeOneOff()";
 }
 
 InProcessContextFactory::~InProcessContextFactory() {
   DCHECK(per_compositor_data_.empty());
 }
 
 void InProcessContextFactory::CreateOutputSurface(
@@ skipping 40 matching lines @@
   if (use_test_surface_) {
     bool flipped_output_surface = false;
     real_output_surface = make_scoped_ptr(new cc::PixelTestOutputSurface(
         context_provider, shared_worker_context_provider_,
         flipped_output_surface));
   } else {
     real_output_surface = make_scoped_ptr(new DirectOutputSurface(
         context_provider, shared_worker_context_provider_));
   }
 
-  if (surface_manager_) {
-    scoped_ptr<cc::OnscreenDisplayClient> display_client(
-        new cc::OnscreenDisplayClient(
-            std::move(real_output_surface), surface_manager_,
-            GetSharedBitmapManager(), GetGpuMemoryBufferManager(),
-            compositor->GetRendererSettings(), compositor->task_runner()));
-    scoped_ptr<cc::SurfaceDisplayOutputSurface> surface_output_surface(
-        new cc::SurfaceDisplayOutputSurface(
-            surface_manager_, compositor->surface_id_allocator(),
-            context_provider, shared_worker_context_provider_));
-    display_client->set_surface_output_surface(surface_output_surface.get());
-    surface_output_surface->set_display_client(display_client.get());
+  scoped_ptr<cc::OnscreenDisplayClient> display_client(
+      new cc::OnscreenDisplayClient(
+          std::move(real_output_surface), surface_manager_.get(),
+          GetSharedBitmapManager(), GetGpuMemoryBufferManager(),
+          compositor->GetRendererSettings(), compositor->task_runner()));
+  scoped_ptr<cc::SurfaceDisplayOutputSurface> surface_output_surface(
+      new cc::SurfaceDisplayOutputSurface(
+          surface_manager_.get(), compositor->surface_id_allocator(),
+          context_provider, shared_worker_context_provider_));
+  display_client->set_surface_output_surface(surface_output_surface.get());
+  surface_output_surface->set_display_client(display_client.get());
 
-    compositor->SetOutputSurface(std::move(surface_output_surface));
+  compositor->SetOutputSurface(std::move(surface_output_surface));
 
-    delete per_compositor_data_[compositor.get()];
-    per_compositor_data_[compositor.get()] = display_client.release();
-  } else {
-    compositor->SetOutputSurface(std::move(real_output_surface));
-  }
+  delete per_compositor_data_[compositor.get()];
+  per_compositor_data_[compositor.get()] = display_client.release();
+
+  // In tests, the OnscreenDisplayClient doesn't exist yet and so the resize
+  // message is missed.  Instead of recording it for later, just resize now.
+  ResizeDisplay(compositor.get(), compositor->size());

[enne (OOO), 2016/03/19 01:31:32]

This was needed because when switching to surfaces, one test was failed because
the display was sized to 0x0 and so clipped a bunch of the content via partial
swap.

 }
 
 scoped_ptr<Reflector> InProcessContextFactory::CreateReflector(
     Compositor* mirrored_compositor,
     Layer* mirroring_layer) {
   return make_scoped_ptr(new FakeReflector);
 }
 
 void InProcessContextFactory::RemoveReflector(Reflector* reflector) {
 }
@@ skipping 37 matching lines @@
 
 gpu::GpuMemoryBufferManager*
 InProcessContextFactory::GetGpuMemoryBufferManager() {
   return &gpu_memory_buffer_manager_;
 }
 
 cc::TaskGraphRunner* InProcessContextFactory::GetTaskGraphRunner() {
   return &task_graph_runner_;
 }
 
+cc::SurfaceManager* InProcessContextFactory::GetSurfaceManager() {
+  return surface_manager_.get();
+}
+
 scoped_ptr<cc::SurfaceIdAllocator>
 InProcessContextFactory::CreateSurfaceIdAllocator() {
   scoped_ptr<cc::SurfaceIdAllocator> allocator(
       new cc::SurfaceIdAllocator(next_surface_id_namespace_++));
-  if (surface_manager_)
-    allocator->RegisterSurfaceIdNamespace(surface_manager_);
+  allocator->RegisterSurfaceIdNamespace(surface_manager_.get());
   return allocator;
 }
 
 void InProcessContextFactory::ResizeDisplay(ui::Compositor* compositor,
                                             const gfx::Size& size) {
+  // If it doesn't exist yet, this will be called again later.
   if (!per_compositor_data_.count(compositor))
     return;
   per_compositor_data_[compositor]->display()->Resize(size);
 }
 
 }  // namespace ui