content: Remove blimp compositing dependencies.

content/renderer/gpu/render_widget_compositor.cc

 // Copyright (c) 2013 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 "content/renderer/gpu/render_widget_compositor.h"
 
 #include <stddef.h>
 
 #include <cmath>
 #include <limits>
@@ skipping 12 matching lines @@
 #include "base/task_scheduler/post_task.h"
 #include "base/task_scheduler/task_scheduler.h"
 #include "base/task_scheduler/task_traits.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_timeline.h"
 #include "cc/base/switches.h"
-#include "cc/blimp/engine_picture_cache.h"
-#include "cc/blimp/image_serialization_processor.h"
-#include "cc/blimp/layer_tree_host_remote.h"
-#include "cc/blimp/remote_compositor_bridge.h"
 #include "cc/blink/web_layer_impl.h"
 #include "cc/debug/layer_tree_debug_state.h"
 #include "cc/debug/micro_benchmark.h"
 #include "cc/input/layer_selection_bound.h"
 #include "cc/layers/layer.h"
 #include "cc/output/begin_frame_args.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/copy_output_result.h"
 #include "cc/output/latency_info_swap_promise.h"
 #include "cc/output/swap_promise.h"
-#include "cc/proto/compositor_message.pb.h"
 #include "cc/resources/single_release_callback.h"
 #include "cc/scheduler/begin_frame_source.h"
 #include "cc/trees/latency_info_swap_promise_monitor.h"
 #include "cc/trees/layer_tree_host_in_process.h"
 #include "cc/trees/layer_tree_mutator.h"
 #include "content/common/content_switches_internal.h"
 #include "content/common/layer_tree_settings_factory.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/screen_info.h"
@@ skipping 148 matching lines @@
 
 RenderWidgetCompositor::RenderWidgetCompositor(
     RenderWidgetCompositorDelegate* delegate,
     CompositorDependencies* compositor_deps)
     : num_failed_recreate_attempts_(0),
       delegate_(delegate),
       compositor_deps_(compositor_deps),
       threaded_(!!compositor_deps_->GetCompositorImplThreadTaskRunner()),
       never_visible_(false),
       layout_and_paint_async_callback_(nullptr),
-      remote_proto_channel_receiver_(nullptr),
       weak_factory_(this) {}
 
 void RenderWidgetCompositor::Initialize(float device_scale_factor,
                                         const ScreenInfo& screen_info) {
   base::CommandLine* cmd = base::CommandLine::ForCurrentProcess();
   cc::LayerTreeSettings settings = GenerateLayerTreeSettings(
       *cmd, compositor_deps_, device_scale_factor, screen_info);
 
   animation_host_ = cc::AnimationHost::CreateMainInstance();
-
-  if (cmd->HasSwitch(switches::kUseRemoteCompositing)) {
-    DCHECK(!threaded_);
-
-    cc::LayerTreeHostRemote::InitParams params;
-    params.client = this;
-    params.main_task_runner =
-        compositor_deps_->GetCompositorMainThreadTaskRunner();
-    params.mutator_host = animation_host_.get();
-    params.remote_compositor_bridge =
-        GetContentClient()->renderer()->CreateRemoteCompositorBridge(
-            this, params.main_task_runner);
-    params.engine_picture_cache =
-        compositor_deps_->GetImageSerializationProcessor()
-            ->CreateEnginePictureCache();
-    params.settings = &settings;
-    layer_tree_host_ = base::MakeUnique<cc::LayerTreeHostRemote>(&params);
-  } else {
     cc::LayerTreeHostInProcess::InitParams params;

[Charlie Reis, 2017/01/19 23:37:33]

Style nit: Fix indent on this block.

(Might be worth running git cl format on the CL?)

[Khushal, 2017/01/19 23:47:17]

Woops. Done.

     params.client = this;
     params.settings = &settings;
     params.task_graph_runner = compositor_deps_->GetTaskGraphRunner();
     params.main_task_runner =
         compositor_deps_->GetCompositorMainThreadTaskRunner();
     params.mutator_host = animation_host_.get();
     if (base::TaskScheduler::GetInstance()) {
       params.image_worker_task_runner =
           base::CreateSequencedTaskRunnerWithTraits(
               base::TaskTraits()
                   .WithPriority(base::TaskPriority::BACKGROUND)
                   .WithShutdownBehavior(
                       base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN));
     }
     if (!threaded_) {
       // Single-threaded layout tests.
       layer_tree_host_ =
           cc::LayerTreeHostInProcess::CreateSingleThreaded(this, &params);
     } else {
       layer_tree_host_ = cc::LayerTreeHostInProcess::CreateThreaded(
           compositor_deps_->GetCompositorImplThreadTaskRunner(), &params);
     }
-  }
-
   DCHECK(layer_tree_host_);
 }
 
 RenderWidgetCompositor::~RenderWidgetCompositor() = default;
 
 // static
 cc::LayerTreeSettings RenderWidgetCompositor::GenerateLayerTreeSettings(
     const base::CommandLine& cmd,
     CompositorDependencies* compositor_deps,
     float device_scale_factor,
@@ skipping 813 matching lines @@
   delegate_->RequestScheduleAnimation();
 }
 
 void RenderWidgetCompositor::DidSubmitCompositorFrame() {}
 
 void RenderWidgetCompositor::DidLoseCompositorFrameSink() {
   // The CompositorFrameSink is not lost in layout tests (single thread mode).
   NOTREACHED();
 }
 
-void RenderWidgetCompositor::SetProtoReceiver(ProtoReceiver* receiver) {
-  remote_proto_channel_receiver_ = receiver;
-}
-
-void RenderWidgetCompositor::SendCompositorProto(
-    const cc::proto::CompositorMessage& proto) {
-  int signed_size = proto.ByteSize();
-  size_t unsigned_size = base::checked_cast<size_t>(signed_size);
-  std::vector<uint8_t> serialized(unsigned_size);
-  proto.SerializeToArray(serialized.data(), signed_size);
-  delegate_->ForwardCompositorProto(serialized);
-}
-
 void RenderWidgetCompositor::SetFrameSinkId(
     const cc::FrameSinkId& frame_sink_id) {
   frame_sink_id_ = frame_sink_id;
   layer_tree_host_->SetFrameSinkId(frame_sink_id);
 }
 
-void RenderWidgetCompositor::OnHandleCompositorProto(
-    const std::vector<uint8_t>& proto) {
-  DCHECK(remote_proto_channel_receiver_);
-
-  std::unique_ptr<cc::proto::CompositorMessage> deserialized(
-      new cc::proto::CompositorMessage);
-  int signed_size = base::checked_cast<int>(proto.size());
-  if (!deserialized->ParseFromArray(proto.data(), signed_size)) {
-    LOG(ERROR) << "Unable to parse compositor proto.";
-    return;
-  }
-
-  remote_proto_channel_receiver_->OnProtoReceived(std::move(deserialized));
-}
-
 void RenderWidgetCompositor::SetPaintedDeviceScaleFactor(
     float device_scale) {
   layer_tree_host_->GetLayerTree()->SetPaintedDeviceScaleFactor(device_scale);
 }
 
 void RenderWidgetCompositor::SetDeviceColorSpace(
     const gfx::ColorSpace& color_space) {
   layer_tree_host_->GetLayerTree()->SetDeviceColorSpace(color_space);
 }
 
 }  // namespace content