views/mus: Install a mus-friend ContextFactory for tests.

ash/mus/non_client_frame_controller_unittest.cc

 // Copyright 2017 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 "ash/mus/non_client_frame_controller.h"
 
 #include "ash/common/ash_layout_constants.h"
 #include "ash/mus/top_level_window_factory.h"
 #include "ash/mus/window_manager_application.h"
 #include "ash/test/ash_test_base.h"
 #include "ash/test/ash_test_helper.h"
 #include "cc/base/math_util.h"
 #include "cc/output/compositor_frame.h"
-#include "cc/output/compositor_frame_sink_client.h"
 #include "cc/quads/solid_color_draw_quad.h"
-#include "cc/scheduler/begin_frame_source.h"
-#include "cc/scheduler/delay_based_time_source.h"
-#include "cc/test/fake_compositor_frame_sink.h"
-#include "cc/test/test_gpu_memory_buffer_manager.h"
-#include "cc/test/test_task_graph_runner.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "services/ui/public/interfaces/window_manager_constants.mojom.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/test/draw_waiter_for_test.h"
+#include "ui/compositor/test/fake_context_factory.h"
 #include "ui/views/widget/widget.h"
 
 namespace ash {
 namespace mus {
 
 namespace {
 
 gfx::Rect GetQuadBoundsInScreen(const cc::DrawQuad* quad) {
   return cc::MathUtil::MapEnclosingClippedRect(
       quad->shared_quad_state->quad_to_target_transform, quad->visible_rect);
@@ skipping 22 matching lines @@
   DCHECK_EQ(1u, frame.render_pass_list.size());
   const cc::QuadList& quad_list = frame.render_pass_list[0]->quad_list;
   for (const auto* quad : quad_list) {
     if (quad->material == cc::DrawQuad::Material::TILED_CONTENT &&
         GetQuadBoundsInScreen(quad) == screen_rect)
       return true;
   }
   return false;
 }
 
-class FakeCompositorFrameSink : public cc::FakeCompositorFrameSink {
- public:
-  FakeCompositorFrameSink()
-      : cc::FakeCompositorFrameSink(cc::TestContextProvider::Create(),
-                                    cc::TestContextProvider::CreateWorker()) {}
-  ~FakeCompositorFrameSink() override = default;
-
- private:
-  // cc::FakeCompositorFrameSink:
-  bool BindToClient(cc::CompositorFrameSinkClient* client) override {
-    if (!cc::FakeCompositorFrameSink::BindToClient(client))
-      return false;
-    begin_frame_source_ = base::MakeUnique<cc::BackToBackBeginFrameSource>(
-        base::MakeUnique<cc::DelayBasedTimeSource>(
-            base::ThreadTaskRunnerHandle::Get().get()));
-    client_->SetBeginFrameSource(begin_frame_source_.get());
-    return true;
-  }
-
-  std::unique_ptr<cc::BeginFrameSource> begin_frame_source_;
-
-  DISALLOW_COPY_AND_ASSIGN(FakeCompositorFrameSink);
-};
-
 }  // namespace
 
-class NonClientFrameControllerTest : public test::AshTestBase,
-                                     public ui::ContextFactory {
+class NonClientFrameControllerTest : public test::AshTestBase {
  public:
   NonClientFrameControllerTest() = default;
   ~NonClientFrameControllerTest() override = default;
 
   const cc::CompositorFrame& GetLastCompositorFrame() const {
-    return *frame_sink_->last_sent_frame();
+    return context_factory_.GetLastCompositorFrame();
   }
 
   // test::AshTestBase:
   void SetUp() override {
     aura::Env* env = aura::Env::GetInstance();
     DCHECK(env);
     context_factory_to_restore_ = env->context_factory();
-    env->set_context_factory(this);
+    env->set_context_factory(&context_factory_);
     AshTestBase::SetUp();
   }
 
   void TearDown() override {
     AshTestBase::TearDown();
     aura::Env::GetInstance()->set_context_factory(context_factory_to_restore_);
   }
 
-  // ui::ContextFactory::
-  void CreateCompositorFrameSink(
-      base::WeakPtr<ui::Compositor> compositor) override {
-    auto frame_sink = base::MakeUnique<FakeCompositorFrameSink>();
-    frame_sink_ = frame_sink.get();
-    compositor->SetCompositorFrameSink(std::move(frame_sink));
-  }
-  scoped_refptr<cc::ContextProvider> SharedMainThreadContextProvider()
-      override {
-    return nullptr;
-  }
-  void RemoveCompositor(ui::Compositor* compositor) override {
-    frame_sink_ = nullptr;
-  }
-  bool DoesCreateTestContexts() override { return true; }
-  uint32_t GetImageTextureTarget(gfx::BufferFormat format,
-                                 gfx::BufferUsage usage) override {
-    return GL_TEXTURE_2D;
-  }
-  gpu::GpuMemoryBufferManager* GetGpuMemoryBufferManager() override {
-    return &gpu_memory_buffer_manager_;
-  }
-  cc::TaskGraphRunner* GetTaskGraphRunner() override {
-    return &task_graph_runner_;
-  }
-  void AddObserver(ui::ContextFactoryObserver* observer) override {}
-  void RemoveObserver(ui::ContextFactoryObserver* observer) override {}
-
  private:
+  ui::FakeContextFactory context_factory_;
   ui::ContextFactory* context_factory_to_restore_ = nullptr;
-  cc::FakeCompositorFrameSink* frame_sink_ = nullptr;
-  cc::TestTaskGraphRunner task_graph_runner_;
-  cc::TestGpuMemoryBufferManager gpu_memory_buffer_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(NonClientFrameControllerTest);
 };
 
 TEST_F(NonClientFrameControllerTest, ContentRegionNotDrawnForClient) {
   std::map<std::string, std::vector<uint8_t>> properties;
   std::unique_ptr<aura::Window> window(mus::CreateAndParentTopLevelWindow(
       ash_test_helper()->window_manager_app()->window_manager(),
       ui::mojom::WindowType::WINDOW, &properties));
   ASSERT_TRUE(window);
@@ skipping 56 matching lines @@
 
     // And there will be a content quad for the window caption.
     gfx::Rect caption_bound(widget_bound);
     caption_bound.set_height(caption_height);
     EXPECT_TRUE(FindTiledContentQuad(frame, caption_bound));
   }
 }
 
 }  // namespace mus
 }  // namespace ash