content/blimp: Remove unused compositing mode switches.

blimp/client/core/compositor/blimp_compositor.cc

 // Copyright 2015 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 "blimp/client/core/compositor/blimp_compositor.h"
 
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 101 matching lines @@
 
  private:
   std::unique_ptr<cc::CopyOutputRequest> copy_request_;
   base::WeakPtr<BlimpCompositor> compositor_weak_ptr_;
   scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
 };
 
 // static
 std::unique_ptr<BlimpCompositor> BlimpCompositor::Create(
     BlimpCompositorDependencies* compositor_dependencies,
-    BlimpCompositorClient* client,
-    bool use_threaded_layer_tree_host) {
+    BlimpCompositorClient* client) {
   std::unique_ptr<BlimpCompositor> compositor =
-      base::WrapUnique(new BlimpCompositor(compositor_dependencies, client,
-                                           use_threaded_layer_tree_host));
+      base::WrapUnique(new BlimpCompositor(compositor_dependencies, client));
   compositor->Initialize();
   return compositor;
 }
 
 BlimpCompositor::BlimpCompositor(
     BlimpCompositorDependencies* compositor_dependencies,
-    BlimpCompositorClient* client,
-    bool use_threaded_layer_tree_host)
-    : use_threaded_layer_tree_host_(use_threaded_layer_tree_host),
-      client_(client),
+    BlimpCompositorClient* client)
+    : client_(client),
       compositor_dependencies_(compositor_dependencies),
       frame_sink_id_(compositor_dependencies_->GetEmbedderDependencies()
                          ->AllocateFrameSinkId()),
       proxy_client_(nullptr),
       bound_to_proxy_(false),
       compositor_frame_sink_request_pending_(false),
       layer_(cc::Layer::Create()),
-      remote_proto_channel_receiver_(nullptr),
-      outstanding_commits_(0U),
       weak_ptr_factory_(this) {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void BlimpCompositor::Initialize() {
   surface_id_allocator_ = base::MakeUnique<cc::SurfaceIdAllocator>();
   GetEmbedderDeps()->GetSurfaceManager()->RegisterFrameSinkId(frame_sink_id_);
   surface_factory_ = base::MakeUnique<cc::SurfaceFactory>(
       frame_sink_id_, GetEmbedderDeps()->GetSurfaceManager(), this);
   animation_host_ = cc::AnimationHost::CreateMainInstance();
   host_ = CreateLayerTreeHost();
 
-  if (use_threaded_layer_tree_host_) {
     std::unique_ptr<cc::ClientPictureCache> client_picture_cache =
         compositor_dependencies_->GetImageSerializationProcessor()
             ->CreateClientPictureCache();
     compositor_state_deserializer_ =
         base::MakeUnique<cc::CompositorStateDeserializer>(
             host_.get(), std::move(client_picture_cache), this);
-  }
 }
 
 BlimpCompositor::~BlimpCompositor() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DestroyLayerTreeHost();
   GetEmbedderDeps()->GetSurfaceManager()->InvalidateFrameSinkId(frame_sink_id_);
 }
 
 void BlimpCompositor::SetVisible(bool visible) {
   host_->SetVisible(visible);
 }
 
 bool BlimpCompositor::IsVisible() const {
   return host_->IsVisible();
 }
 
 bool BlimpCompositor::HasPendingFrameUpdateFromEngine() const {
   return pending_frame_update_.get() != nullptr;
 }
 
 void BlimpCompositor::RequestCopyOfOutput(
     std::unique_ptr<cc::CopyOutputRequest> copy_request,
     bool flush_pending_update) {
   // If we don't have a FrameSink, fail right away.
   if (!bound_to_proxy_)
     return;
 
-  if (!use_threaded_layer_tree_host_) {
-    RequestCopyOfOutputDeprecated(std::move(copy_request));
-    return;
-  }
-
   if (flush_pending_update) {
     // Always request a commit when queuing the promise to make sure that any
     // frames pending draws are cleared from the pipeline.
     host_->QueueSwapPromise(base::MakeUnique<FrameTrackingSwapPromise>(
         std::move(copy_request), weak_ptr_factory_.GetWeakPtr(),
         base::ThreadTaskRunnerHandle::Get()));
     host_->SetNeedsCommit();
   } else if (!local_frame_id_.is_null()) {
     // Make a copy request for the surface directly.
     surface_factory_->RequestCopyOfSurface(local_frame_id_,
                                            std::move(copy_request));
   }
 }
 
-void BlimpCompositor::RequestCopyOfOutputDeprecated(
-    std::unique_ptr<cc::CopyOutputRequest> copy_request) {
-  DCHECK(!use_threaded_layer_tree_host_);
-
-  if (outstanding_commits_ == 0) {
-    surface_factory_->RequestCopyOfSurface(local_frame_id_,
-                                           std::move(copy_request));
-    return;
-  }
-
-  pending_commit_trackers_.push_back(
-      std::make_pair(outstanding_commits_, std::move(copy_request)));
-}
-
 void BlimpCompositor::UpdateLayerTreeHost() {
-  DCHECK(use_threaded_layer_tree_host_);
-
   // UpdateLayerTreeHost marks the end of reporting of any deltas from the impl
   // thread. So send a client state update if the local state was modified now.
   FlushClientState();
 
   if (pending_frame_update_) {
-    DCHECK(use_threaded_layer_tree_host_);
     compositor_state_deserializer_->DeserializeCompositorUpdate(
         pending_frame_update_->layer_tree_host());
     pending_frame_update_ = nullptr;
     cc::proto::CompositorMessage frame_ack;
     frame_ack.set_frame_ack(true);
     client_->SendCompositorMessage(frame_ack);
   }
 
   // Send back any deltas that have not yet been resolved on the main thread
   // back to the impl thread.
   compositor_state_deserializer_->SendUnappliedDeltasToLayerTreeHost();
 }
 
 void BlimpCompositor::ApplyViewportDeltas(
     const gfx::Vector2dF& inner_delta,
     const gfx::Vector2dF& outer_delta,
     const gfx::Vector2dF& elastic_overscroll_delta,
     float page_scale,
     float top_controls_delta) {
-  DCHECK(use_threaded_layer_tree_host_);
   compositor_state_deserializer_->ApplyViewportDeltas(
       inner_delta, outer_delta, elastic_overscroll_delta, page_scale,
       top_controls_delta);
 }
 
 void BlimpCompositor::RequestNewCompositorFrameSink() {
   DCHECK(!bound_to_proxy_);
   DCHECK(!compositor_frame_sink_request_pending_);
 
   compositor_frame_sink_request_pending_ = true;
   GetEmbedderDeps()->GetContextProviders(
       base::Bind(&BlimpCompositor::OnContextProvidersCreated,
                  weak_ptr_factory_.GetWeakPtr()));
 }
 
 void BlimpCompositor::DidInitializeCompositorFrameSink() {
   compositor_frame_sink_request_pending_ = false;
 }
 
-void BlimpCompositor::DidCommitAndDrawFrame() {
-  if (use_threaded_layer_tree_host_)
-    return;
-
-  DCHECK_GT(outstanding_commits_, 0U);
-  outstanding_commits_--;
-
-  for (auto it = pending_commit_trackers_.begin();
-       it != pending_commit_trackers_.end();) {
-    if (--it->first == 0) {
-      if (bound_to_proxy_) {
-        surface_factory_->RequestCopyOfSurface(local_frame_id_,
-                                               std::move(it->second));
-      }
-      it = pending_commit_trackers_.erase(it);
-    } else {
-      ++it;
-    }
-  }
-}
-
-void BlimpCompositor::SetProtoReceiver(ProtoReceiver* receiver) {
-  DCHECK(!use_threaded_layer_tree_host_);
-  remote_proto_channel_receiver_ = receiver;
-}
-
-void BlimpCompositor::SendCompositorProto(
-    const cc::proto::CompositorMessage& proto) {
-  DCHECK(!use_threaded_layer_tree_host_);
-  client_->SendCompositorMessage(proto);
-}
+void BlimpCompositor::DidCommitAndDrawFrame() {}
 
 void BlimpCompositor::OnCompositorMessageReceived(
     std::unique_ptr<cc::proto::CompositorMessage> message) {
-  if (message->has_to_impl()) {
-    HandleCompositorMessageToImpl(std::move(message));
-    return;
-  }
-
-  DCHECK(use_threaded_layer_tree_host_);
   cc::proto::CompositorMessage* message_received = message.get();
 
   if (message_received->has_layer_tree_host()) {
     DCHECK(!pending_frame_update_)
         << "We should have only a single frame in flight";
 
     UMA_HISTOGRAM_MEMORY_KB("Blimp.Compositor.CommitSizeKb",
                             (float)message->ByteSize() / 1024);
     BlimpStats::GetInstance()->Add(BlimpStats::COMMIT, 1);
 
     pending_frame_update_ = std::move(message);
-    outstanding_commits_++;
     host_->SetNeedsAnimate();
   }
 
   if (message_received->client_state_update_ack()) {
     DCHECK(client_state_update_ack_pending_);
 
     client_state_update_ack_pending_ = false;
     compositor_state_deserializer_->DidApplyStateUpdatesOnEngine();
 
     // If there are any updates that we have queued because we were waiting for
     // an ack, send them now.
     FlushClientState();
   }
 }
 
-void BlimpCompositor::HandleCompositorMessageToImpl(
-    std::unique_ptr<cc::proto::CompositorMessage> message) {
-  DCHECK(!use_threaded_layer_tree_host_);
-  DCHECK(message->has_to_impl());
-
-  const cc::proto::CompositorMessageToImpl to_impl_proto = message->to_impl();
-  DCHECK(to_impl_proto.has_message_type());
-
-  if (to_impl_proto.message_type() ==
-      cc::proto::CompositorMessageToImpl::START_COMMIT) {
-    BlimpStats::GetInstance()->Add(BlimpStats::COMMIT, 1);
-    outstanding_commits_++;
-  }
-
-  switch (to_impl_proto.message_type()) {
-    case cc::proto::CompositorMessageToImpl::UNKNOWN:
-      NOTIMPLEMENTED() << "Ignoring message of UNKNOWN type";
-      break;
-    case cc::proto::CompositorMessageToImpl::START_COMMIT:
-      UMA_HISTOGRAM_MEMORY_KB("Blimp.Compositor.CommitSizeKb",
-                              (float)message->ByteSize() / 1024);
-    default:
-      // We should have a receiver if we're getting compositor messages that
-      // are not INITIALIZE_IMPL or CLOSE_IMPL.
-      DCHECK(remote_proto_channel_receiver_);
-      remote_proto_channel_receiver_->OnProtoReceived(std::move(message));
-  }
-}
-
-// Returns a reference to the InputHandler owned by layer tree host.
 const base::WeakPtr<cc::InputHandler>& BlimpCompositor::GetInputHandler() {
   return host_->GetInputHandler();
 }
 
 void BlimpCompositor::OnContextProvidersCreated(
     const scoped_refptr<cc::ContextProvider>& compositor_context_provider,
     const scoped_refptr<cc::ContextProvider>& worker_context_provider) {
   DCHECK(!bound_to_proxy_) << "Any connection to the old CompositorFrameSink "
                               "should have been destroyed";
 
@@ skipping 145 matching lines @@
 
 std::unique_ptr<cc::LayerTreeHostInProcess>
 BlimpCompositor::CreateLayerTreeHost() {
   DCHECK(animation_host_);
   std::unique_ptr<cc::LayerTreeHostInProcess> host;
 
   cc::LayerTreeHostInProcess::InitParams params;
   params.client = this;
   params.task_graph_runner = compositor_dependencies_->GetTaskGraphRunner();
   params.main_task_runner = base::ThreadTaskRunnerHandle::Get();
-  if (!use_threaded_layer_tree_host_) {
     params.image_serialization_processor =
         compositor_dependencies_->GetImageSerializationProcessor();
-  }
 
   cc::LayerTreeSettings* settings =
       compositor_dependencies_->GetLayerTreeSettings();
   params.settings = settings;
   params.mutator_host = animation_host_.get();
 
   scoped_refptr<base::SingleThreadTaskRunner> compositor_task_runner =
       compositor_dependencies_->GetCompositorTaskRunner();
 
-  if (use_threaded_layer_tree_host_) {
     host = cc::LayerTreeHostInProcess::CreateThreaded(compositor_task_runner,
                                                       &params);
-  } else {
-    host = cc::LayerTreeHostInProcess::CreateRemoteClient(
-        this /* remote_proto_channel */, compositor_task_runner, &params);
-  }
 
   return host;
 }
 
 void BlimpCompositor::DestroyLayerTreeHost() {
   DCHECK(host_);
 
   // Tear down the output surface connection with the old LayerTreeHost
   // instance.
   DestroyDelegatedContent();
 
   // Destroy the old LayerTreeHost state.
   host_.reset();
 
   // Cancel any outstanding CompositorFrameSink requests.  That way if we get an
   // async callback related to the old request we know to drop it.
   compositor_frame_sink_request_pending_ = false;
-
-  // Make sure we don't have a receiver at this point.
-  DCHECK(!remote_proto_channel_receiver_);
 }
 
 }  // namespace client
 }  // namespace blimp