Remove external begin frame source parameter and settings

cc/trees/layer_tree_host_in_process.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_in_process.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 31 matching lines @@
 #include "cc/layers/heads_up_display_layer.h"
 #include "cc/layers/heads_up_display_layer_impl.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/layer_iterator.h"
 #include "cc/layers/layer_proto_converter.h"
 #include "cc/layers/painted_scrollbar_layer.h"
 #include "cc/proto/gfx_conversions.h"
 #include "cc/proto/layer_tree.pb.h"
 #include "cc/proto/layer_tree_host.pb.h"
 #include "cc/resources/ui_resource_manager.h"
-#include "cc/scheduler/begin_frame_source.h"
 #include "cc/trees/draw_property_utils.h"
 #include "cc/trees/layer_tree_host_client.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_host_impl.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/property_tree_builder.h"
 #include "cc/trees/proxy_main.h"
 #include "cc/trees/remote_channel_impl.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/swap_promise_manager.h"
@@ skipping 66 matching lines @@
 LayerTreeHostInProcess::InitParams::~InitParams() {}
 
 std::unique_ptr<LayerTreeHostInProcess> LayerTreeHostInProcess::CreateThreaded(
     scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
     InitParams* params) {
   DCHECK(params->main_task_runner.get());
   DCHECK(impl_task_runner.get());
   DCHECK(params->settings);
   std::unique_ptr<LayerTreeHostInProcess> layer_tree_host(
       new LayerTreeHostInProcess(params, CompositorMode::THREADED));
-  layer_tree_host->InitializeThreaded(
-      params->main_task_runner, impl_task_runner,
-      std::move(params->external_begin_frame_source));
+  layer_tree_host->InitializeThreaded(params->main_task_runner,
+                                      impl_task_runner);
   return layer_tree_host;
 }
 
 std::unique_ptr<LayerTreeHostInProcess>
 LayerTreeHostInProcess::CreateSingleThreaded(
     LayerTreeHostSingleThreadClient* single_thread_client,
     InitParams* params) {
   DCHECK(params->settings);
   std::unique_ptr<LayerTreeHostInProcess> layer_tree_host(
       new LayerTreeHostInProcess(params, CompositorMode::SINGLE_THREADED));
-  layer_tree_host->InitializeSingleThreaded(
-      single_thread_client, params->main_task_runner,
-      std::move(params->external_begin_frame_source));
+  layer_tree_host->InitializeSingleThreaded(single_thread_client,
+                                            params->main_task_runner);
   return layer_tree_host;
 }
 
 std::unique_ptr<LayerTreeHostInProcess>
 LayerTreeHostInProcess::CreateRemoteServer(
     RemoteProtoChannel* remote_proto_channel,
     InitParams* params) {
   DCHECK(params->main_task_runner.get());
   DCHECK(params->settings);
   DCHECK(remote_proto_channel);
   TRACE_EVENT0("cc.remote", "LayerTreeHostInProcess::CreateRemoteServer");
 
-  // Using an external begin frame source is not supported on the server in
-  // remote mode.
-  DCHECK(!params->settings->use_external_begin_frame_source);
-  DCHECK(!params->external_begin_frame_source);
   DCHECK(params->image_serialization_processor);
 
   std::unique_ptr<LayerTreeHostInProcess> layer_tree_host(
       new LayerTreeHostInProcess(params, CompositorMode::REMOTE));
   layer_tree_host->InitializeRemoteServer(remote_proto_channel,
                                           params->main_task_runner);
   return layer_tree_host;
 }
 
 std::unique_ptr<LayerTreeHostInProcess>
 LayerTreeHostInProcess::CreateRemoteClient(
     RemoteProtoChannel* remote_proto_channel,
     scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
     InitParams* params) {
   DCHECK(params->main_task_runner.get());
   DCHECK(params->settings);
   DCHECK(remote_proto_channel);
-
-  // Using an external begin frame source is not supported in remote mode.
-  // TODO(khushalsagar): Add support for providing an external begin frame
-  // source on the client LayerTreeHostInProcess. crbug/576962
-  DCHECK(!params->settings->use_external_begin_frame_source);
-  DCHECK(!params->external_begin_frame_source);
   DCHECK(params->image_serialization_processor);
 
   std::unique_ptr<LayerTreeHostInProcess> layer_tree_host(
       new LayerTreeHostInProcess(params, CompositorMode::REMOTE));
   layer_tree_host->InitializeRemoteClient(
       remote_proto_channel, params->main_task_runner, impl_task_runner);
   return layer_tree_host;
 }
 
 LayerTreeHostInProcess::LayerTreeHostInProcess(InitParams* params,
@@ skipping 30 matching lines @@
       image_serialization_processor_(params->image_serialization_processor) {
   DCHECK(task_graph_runner_);
   DCHECK(layer_tree_);
 
   rendering_stats_instrumentation_->set_record_rendering_stats(
       debug_state_.RecordRenderingStats());
 }
 
 void LayerTreeHostInProcess::InitializeThreaded(
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
-    scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
-    std::unique_ptr<BeginFrameSource> external_begin_frame_source) {
+    scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
   task_runner_provider_ =
       TaskRunnerProvider::Create(main_task_runner, impl_task_runner);
   std::unique_ptr<ProxyMain> proxy_main =
       ProxyMain::CreateThreaded(this, task_runner_provider_.get());
-  InitializeProxy(std::move(proxy_main),
-                  std::move(external_begin_frame_source));
+  InitializeProxy(std::move(proxy_main));
 }
 
 void LayerTreeHostInProcess::InitializeSingleThreaded(
     LayerTreeHostSingleThreadClient* single_thread_client,
-    scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
-    std::unique_ptr<BeginFrameSource> external_begin_frame_source) {
+    scoped_refptr<base::SingleThreadTaskRunner> main_task_runner) {
   task_runner_provider_ = TaskRunnerProvider::Create(main_task_runner, nullptr);
   InitializeProxy(SingleThreadProxy::Create(this, single_thread_client,
-                                            task_runner_provider_.get()),
-                  std::move(external_begin_frame_source));
+                                            task_runner_provider_.get()));
 }
 
 void LayerTreeHostInProcess::InitializeRemoteServer(
     RemoteProtoChannel* remote_proto_channel,
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner) {
   task_runner_provider_ = TaskRunnerProvider::Create(main_task_runner, nullptr);
 
   if (image_serialization_processor_) {
     engine_picture_cache_ =
         image_serialization_processor_->CreateEnginePictureCache();
     layer_tree_->set_engine_picture_cache(engine_picture_cache_.get());
   }
   InitializeProxy(ProxyMain::CreateRemote(remote_proto_channel, this,
-                                          task_runner_provider_.get()),
-                  nullptr);
+                                          task_runner_provider_.get()));
 }
 
 void LayerTreeHostInProcess::InitializeRemoteClient(
     RemoteProtoChannel* remote_proto_channel,
     scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner) {
   task_runner_provider_ =
       TaskRunnerProvider::Create(main_task_runner, impl_task_runner);
 
   if (image_serialization_processor_) {
     client_picture_cache_ =
         image_serialization_processor_->CreateClientPictureCache();
     layer_tree_->set_client_picture_cache(client_picture_cache_.get());
   }
 
   // For the remote mode, the RemoteChannelImpl implements the Proxy, which is
   // owned by the LayerTreeHostInProcess. The RemoteChannelImpl pipes requests
   // which need to handled locally, for instance the Output Surface creation to
   // the LayerTreeHostInProcess on the client, while the other requests are sent
   // to the RemoteChannelMain on the server which directs them to ProxyMain and
   // the remote server LayerTreeHostInProcess.
   InitializeProxy(base::MakeUnique<RemoteChannelImpl>(
-                      this, remote_proto_channel, task_runner_provider_.get()),
-                  nullptr);
+      this, remote_proto_channel, task_runner_provider_.get()));
 }
 
 void LayerTreeHostInProcess::InitializeForTesting(
     std::unique_ptr<TaskRunnerProvider> task_runner_provider,
-    std::unique_ptr<Proxy> proxy_for_testing,
-    std::unique_ptr<BeginFrameSource> external_begin_frame_source) {
+    std::unique_ptr<Proxy> proxy_for_testing) {
   task_runner_provider_ = std::move(task_runner_provider);
 
   InitializePictureCacheForTesting();
 
-  InitializeProxy(std::move(proxy_for_testing),
-                  std::move(external_begin_frame_source));
+  InitializeProxy(std::move(proxy_for_testing));
 }
 
 void LayerTreeHostInProcess::InitializePictureCacheForTesting() {
   if (!image_serialization_processor_)
     return;
 
   // Initialize both engine and client cache to ensure serialization tests
   // with a single LayerTreeHostInProcess can work correctly.
   engine_picture_cache_ =
       image_serialization_processor_->CreateEnginePictureCache();
   layer_tree_->set_engine_picture_cache(engine_picture_cache_.get());
   client_picture_cache_ =
       image_serialization_processor_->CreateClientPictureCache();
   layer_tree_->set_client_picture_cache(client_picture_cache_.get());
 }
 
 void LayerTreeHostInProcess::SetTaskRunnerProviderForTesting(
     std::unique_ptr<TaskRunnerProvider> task_runner_provider) {
   DCHECK(!task_runner_provider_);
   task_runner_provider_ = std::move(task_runner_provider);
 }
 
 void LayerTreeHostInProcess::SetUIResourceManagerForTesting(
     std::unique_ptr<UIResourceManager> ui_resource_manager) {
   ui_resource_manager_ = std::move(ui_resource_manager);
 }
 
-void LayerTreeHostInProcess::InitializeProxy(
-    std::unique_ptr<Proxy> proxy,
-    std::unique_ptr<BeginFrameSource> external_begin_frame_source) {
+void LayerTreeHostInProcess::InitializeProxy(std::unique_ptr<Proxy> proxy) {
   TRACE_EVENT0("cc", "LayerTreeHostInProcess::InitializeForReal");
   DCHECK(task_runner_provider_);
 
   proxy_ = std::move(proxy);
-  proxy_->Start(std::move(external_begin_frame_source));
+  proxy_->Start();
 
   layer_tree_->animation_host()->SetSupportsScrollAnimations(
       proxy_->SupportsImplScrolling());
 }
 
 LayerTreeHostInProcess::~LayerTreeHostInProcess() {
   TRACE_EVENT0("cc", "LayerTreeHostInProcess::~LayerTreeHostInProcess");
 
   // Clear any references into the LayerTreeHostInProcess.
   layer_tree_.reset();
@@ skipping 692 matching lines @@
 
   debug_state_.FromProtobuf(proto.debug_state());
   has_gpu_rasterization_trigger_ = proto.has_gpu_rasterization_trigger();
   content_is_suitable_for_gpu_rasterization_ =
       proto.content_is_suitable_for_gpu_rasterization();
   id_ = proto.id();
   next_commit_forces_redraw_ = proto.next_commit_forces_redraw();
 }
 
 }  // namespace cc