ui + mus: Split ContextFactory into ContextFactory(Client) and ContextFactoryPrivate

ui/compositor/layer_animator_unittest.cc

 // Copyright (c) 2012 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/layer_animator.h"
 
 #include <memory>
 #include <string>
 #include <vector>
 
@@ skipping 2589 matching lines @@
       collection_delegate.GetLayerAnimatorCollection()->HasActiveAnimators());
 
   layer.reset();
   EXPECT_EQ(NULL, animator->delegate());
   EXPECT_FALSE(
       collection_delegate.GetLayerAnimatorCollection()->HasActiveAnimators());
 }
 
 TEST(LayerAnimatorTest, LayerMovedBetweenCompositorsDuringAnimation) {
   bool enable_pixel_output = false;
-  ui::ContextFactory* context_factory =
-      InitializeContextFactoryForTests(enable_pixel_output);
+  ui::ContextFactory* context_factory = nullptr;
+  ui::ContextFactoryPrivate* context_factory_private = nullptr;
+  InitializeContextFactoryForTests(enable_pixel_output, &context_factory,
+                                   &context_factory_private);
   const gfx::Rect bounds(10, 10, 100, 100);
-  std::unique_ptr<TestCompositorHost> host_1(
-      TestCompositorHost::Create(bounds, context_factory));
-  std::unique_ptr<TestCompositorHost> host_2(
-      TestCompositorHost::Create(bounds, context_factory));
+  std::unique_ptr<TestCompositorHost> host_1(TestCompositorHost::Create(
+      bounds, context_factory, context_factory_private));
+  std::unique_ptr<TestCompositorHost> host_2(TestCompositorHost::Create(
+      bounds, context_factory, context_factory_private));
   host_1->Show();
   host_2->Show();
 
   Compositor* compositor_1 = host_1->GetCompositor();
   Layer root_1;
   compositor_1->SetRootLayer(&root_1);
 
   Compositor* compositor_2 = host_2->GetCompositor();
   Layer root_2;
   compositor_2->SetRootLayer(&root_2);
@@ skipping 21 matching lines @@
   EXPECT_TRUE(compositor_2->layer_animator_collection()->HasActiveAnimators());
   EXPECT_TRUE(layer.cc_layer_for_testing()->HasTickingAnimationForTesting());
 
   host_2.reset();
   host_1.reset();
   TerminateContextFactoryForTests();
 }
 
 TEST(LayerAnimatorTest, ThreadedAnimationSurvivesIfLayerRemovedAdded) {
   bool enable_pixel_output = false;
-  ui::ContextFactory* context_factory =
-      InitializeContextFactoryForTests(enable_pixel_output);
+  ui::ContextFactory* context_factory = nullptr;
+  ui::ContextFactoryPrivate* context_factory_private = nullptr;
+  InitializeContextFactoryForTests(enable_pixel_output, &context_factory,
+                                   &context_factory_private);
   const gfx::Rect bounds(10, 10, 100, 100);
-  std::unique_ptr<TestCompositorHost> host(
-      TestCompositorHost::Create(bounds, context_factory));
+  std::unique_ptr<TestCompositorHost> host(TestCompositorHost::Create(
+      bounds, context_factory, context_factory_private));
   host->Show();
 
   Compositor* compositor = host->GetCompositor();
 
   Layer root;
   compositor->SetRootLayer(&root);
 
   Layer layer;
   root.Add(&layer);
 
@@ skipping 272 matching lines @@
   EXPECT_EQ(observer.last_ended_sequence(), nullptr);
   EXPECT_EQ(observer.last_detached_sequence(), first_sequence);
 
   EXPECT_TRUE(observer.AbortedEpochIsBeforeDetachedEpoch());
   EXPECT_TRUE(observer.AbortedEpochIsBeforeStartedEpoch());
   EXPECT_TRUE(observer.AttachedEpochIsBeforeScheduledEpoch());
   EXPECT_TRUE(observer.ScheduledEpochIsBeforeStartedEpoch());
 }
 
 }  // namespace ui