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

ui/compositor/compositor.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/compositor.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <deque>
@@ skipping 54 matching lines @@
 }
 
 void CompositorLock::CancelLock() {
   if (!compositor_)
     return;
   compositor_->UnlockCompositor();
   compositor_ = NULL;
 }
 
 Compositor::Compositor(ui::ContextFactory* context_factory,
+                       ui::ContextFactoryPrivate* context_factory_private,
                        scoped_refptr<base::SingleThreadTaskRunner> task_runner)
     : context_factory_(context_factory),
+      context_factory_private_(context_factory_private),
       root_layer_(NULL),
       widget_(gfx::kNullAcceleratedWidget),
 #if defined(USE_AURA)
       window_(nullptr),
 #endif
       widget_valid_(false),
       compositor_frame_sink_requested_(false),
-      frame_sink_id_(context_factory->AllocateFrameSinkId()),
+      frame_sink_id_(context_factory_private
+                         ? context_factory_private->AllocateFrameSinkId()
+                         : cc::FrameSinkId()),
       task_runner_(task_runner),
       vsync_manager_(new CompositorVSyncManager()),
       device_scale_factor_(0.0f),
       locks_will_time_out_(true),
       compositor_lock_(NULL),
       layer_animator_collection_(this),
       weak_ptr_factory_(this) {
-  context_factory->GetSurfaceManager()->RegisterFrameSinkId(frame_sink_id_);
+  if (context_factory_private) {
+    context_factory_private->GetSurfaceManager()->RegisterFrameSinkId(
+        frame_sink_id_);
+  }
   root_web_layer_ = cc::Layer::Create();
 
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 
   cc::LayerTreeSettings settings;
 
   // This will ensure PictureLayers always can have LCD text, to match the
   // previous behaviour with ContentLayers, where LCD-not-allowed notifications
   // were ignored.
   settings.layers_always_allowed_lcd_text = true;
@@ skipping 120 matching lines @@
     root_layer_->ResetCompositor();
 
   if (animation_timeline_)
     animation_host_->RemoveAnimationTimeline(animation_timeline_.get());
 
   // Stop all outstanding draws before telling the ContextFactory to tear
   // down any contexts that the |host_| may rely upon.
   host_.reset();
 
   context_factory_->RemoveCompositor(this);
-  auto* manager = context_factory_->GetSurfaceManager();
-  for (auto& client : child_frame_sinks_) {
-    DCHECK(client.is_valid());
-    manager->UnregisterFrameSinkHierarchy(frame_sink_id_, client);
+  if (context_factory_private_) {
+    auto* manager = context_factory_private_->GetSurfaceManager();
+    for (auto& client : child_frame_sinks_) {
+      DCHECK(client.is_valid());
+      manager->UnregisterFrameSinkHierarchy(frame_sink_id_, client);
+    }
+    manager->InvalidateFrameSinkId(frame_sink_id_);
   }
-  manager->InvalidateFrameSinkId(frame_sink_id_);
 }
 
 void Compositor::AddFrameSink(const cc::FrameSinkId& frame_sink_id) {
-  context_factory_->GetSurfaceManager()->RegisterFrameSinkHierarchy(
+  if (!context_factory_private_)

[sadrul, 2016/12/09 00:11:03]

Probably should be DCHECK()?

[Fady Samuel, 2016/12/13 19:13:59]

I cannot unfortunately because Chrome still uses ContextFactoryPrivate.

+    return;
+  context_factory_private_->GetSurfaceManager()->RegisterFrameSinkHierarchy(
       frame_sink_id_, frame_sink_id);
   child_frame_sinks_.insert(frame_sink_id);
 }
 
 void Compositor::RemoveFrameSink(const cc::FrameSinkId& frame_sink_id) {
+  if (!context_factory_private_)
+    return;
   auto it = child_frame_sinks_.find(frame_sink_id);
   DCHECK(it != child_frame_sinks_.end());
   DCHECK(it->is_valid());
-  context_factory_->GetSurfaceManager()->UnregisterFrameSinkHierarchy(
+  context_factory_private_->GetSurfaceManager()->UnregisterFrameSinkHierarchy(
       frame_sink_id_, *it);
   child_frame_sinks_.erase(it);
 }
 
 void Compositor::SetCompositorFrameSink(
     std::unique_ptr<cc::CompositorFrameSink> compositor_frame_sink) {
   compositor_frame_sink_requested_ = false;
   host_->SetCompositorFrameSink(std::move(compositor_frame_sink));
   // Display properties are reset when the output surface is lost, so update it
   // to match the Compositor's.
-  context_factory_->SetDisplayVisible(this, host_->IsVisible());
-  context_factory_->SetDisplayColorSpace(this, color_space_);
+  if (context_factory_private_) {
+    context_factory_private_->SetDisplayVisible(this, host_->IsVisible());
+    context_factory_private_->SetDisplayColorSpace(this, color_space_);
+  }
 }
 
 void Compositor::ScheduleDraw() {
   host_->SetNeedsCommit();
 }
 
 void Compositor::SetRootLayer(Layer* root_layer) {
   if (root_layer_ == root_layer)
     return;
   if (root_layer_)
@@ skipping 24 matching lines @@
   host_->SetNeedsCommit();
 }
 
 void Compositor::ScheduleRedrawRect(const gfx::Rect& damage_rect) {
   // TODO(enne): Make this not commit.  See ScheduleFullRedraw.
   host_->SetNeedsRedrawRect(damage_rect);
   host_->SetNeedsCommit();
 }
 
 void Compositor::DisableSwapUntilResize() {
-  context_factory_->ResizeDisplay(this, gfx::Size());
+  context_factory_private_->ResizeDisplay(this, gfx::Size());
 }
 
 void Compositor::SetLatencyInfo(const ui::LatencyInfo& latency_info) {
   std::unique_ptr<cc::SwapPromise> swap_promise(
       new cc::LatencyInfoSwapPromise(latency_info));
   host_->QueueSwapPromise(std::move(swap_promise));
 }
 
 void Compositor::SetScaleAndSize(float scale, const gfx::Size& size_in_pixel) {
   DCHECK_GT(scale, 0);
   if (!size_in_pixel.IsEmpty()) {
     size_ = size_in_pixel;
     host_->GetLayerTree()->SetViewportSize(size_in_pixel);
     root_web_layer_->SetBounds(size_in_pixel);
-    context_factory_->ResizeDisplay(this, size_in_pixel);
+    // TODO(fsamuel): Get rid of ContextFactoryPrivate.
+    if (context_factory_private_)
+      context_factory_private_->ResizeDisplay(this, size_in_pixel);
   }
   if (device_scale_factor_ != scale) {
     device_scale_factor_ = scale;
     host_->GetLayerTree()->SetDeviceScaleFactor(scale);
     if (root_layer_)
       root_layer_->OnDeviceScaleFactorChanged(scale);
   }
 }
 
 void Compositor::SetDisplayColorSpace(const gfx::ColorSpace& color_space) {
   host_->GetLayerTree()->SetDeviceColorSpace(color_space);
   color_space_ = color_space;
   // Color space is reset when the output surface is lost, so this must also be
   // updated then.
-  context_factory_->SetDisplayColorSpace(this, color_space_);
+  // TODO(fsamuel): Get rid of this.
+  if (context_factory_private_)
+    context_factory_private_->SetDisplayColorSpace(this, color_space_);
 }
 
 void Compositor::SetBackgroundColor(SkColor color) {
   host_->GetLayerTree()->set_background_color(color);
   ScheduleDraw();
 }
 
 void Compositor::SetVisible(bool visible) {
   host_->SetVisible(visible);
   // Visibility is reset when the output surface is lost, so this must also be
   // updated then.
-  context_factory_->SetDisplayVisible(this, visible);
+  // TODO(fsamuel): Eliminate this call.
+  if (context_factory_private_)
+    context_factory_private_->SetDisplayVisible(this, visible);
 }
 
 bool Compositor::IsVisible() {
   return host_->IsVisible();
 }
 
 bool Compositor::ScrollLayerTo(int layer_id, const gfx::ScrollOffset& offset) {
   return host_->GetInputHandler()->ScrollLayerTo(layer_id, offset);
 }
 
 bool Compositor::GetScrollOffsetForLayer(int layer_id,
                                          gfx::ScrollOffset* offset) const {
   return host_->GetInputHandler()->GetScrollOffsetForLayer(layer_id, offset);
 }
 
 void Compositor::SetAuthoritativeVSyncInterval(
     const base::TimeDelta& interval) {
-  context_factory_->SetAuthoritativeVSyncInterval(this, interval);
+  if (context_factory_private_)
+    context_factory_private_->SetAuthoritativeVSyncInterval(this, interval);
   vsync_manager_->SetAuthoritativeVSyncInterval(interval);
 }
 
 void Compositor::SetDisplayVSyncParameters(base::TimeTicks timebase,
                                            base::TimeDelta interval) {
   if (interval.is_zero()) {
     // TODO(brianderson): We should not be receiving 0 intervals.
     interval = cc::BeginFrameArgs::DefaultInterval();
   }
 
-  context_factory_->SetDisplayVSyncParameters(this, timebase, interval);
+  if (context_factory_private_) {
+    context_factory_private_->SetDisplayVSyncParameters(this, timebase,
+                                                        interval);
+  }
   vsync_manager_->UpdateVSyncParameters(timebase, interval);
 }
 
 void Compositor::SetAcceleratedWidget(gfx::AcceleratedWidget widget) {
   // This function should only get called once.
   DCHECK(!widget_valid_);
   widget_ = widget;
   widget_valid_ = true;
   if (compositor_frame_sink_requested_)
     context_factory_->CreateCompositorFrameSink(weak_ptr_factory_.GetWeakPtr());
@@ skipping 102 matching lines @@
     observer.OnCompositingEnded(this);
 }
 
 void Compositor::DidSubmitCompositorFrame() {
   base::TimeTicks start_time = base::TimeTicks::Now();
   for (auto& observer : observer_list_)
     observer.OnCompositingStarted(this, start_time);
 }
 
 void Compositor::SetOutputIsSecure(bool output_is_secure) {
-  context_factory_->SetOutputIsSecure(this, output_is_secure);
+  if (context_factory_private_)
+    context_factory_private_->SetOutputIsSecure(this, output_is_secure);
 }
 
 const cc::LayerTreeDebugState& Compositor::GetLayerTreeDebugState() const {
   return host_->GetDebugState();
 }
 
 void Compositor::SetLayerTreeDebugState(
     const cc::LayerTreeDebugState& debug_state) {
   host_->SetDebugState(debug_state);
 }
@@ skipping 19 matching lines @@
   for (auto& observer : observer_list_)
     observer.OnCompositingLockStateChanged(this);
 }
 
 void Compositor::CancelCompositorLock() {
   if (compositor_lock_)
     compositor_lock_->CancelLock();
 }
 
 }  // namespace ui