Add IPC messages to transfer compositor protos

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 <limits>
 #include <string>
 
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/numerics/safe_conversions.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/lock.h"
 #include "base/sys_info.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "cc/animation/animation_host.h"
 #include "cc/animation/animation_timeline.h"
 #include "cc/base/switches.h"
 #include "cc/blink/web_compositor_animation_timeline_impl.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.h"
+#include "cc/trees/remote_proto_channel.h"
 #include "components/scheduler/renderer/renderer_scheduler.h"
 #include "content/common/content_switches_internal.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/public/common/content_switches.h"
 #include "content/renderer/input/input_handler_manager.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "third_party/WebKit/public/platform/WebCompositeAndReadbackAsyncCallback.h"
 #include "third_party/WebKit/public/platform/WebLayoutAndPaintAsyncCallback.h"
 #include "third_party/WebKit/public/platform/WebSize.h"
@@ skipping 160 matching lines @@
 }
 
 RenderWidgetCompositor::RenderWidgetCompositor(
     RenderWidget* widget,
     CompositorDependencies* compositor_deps)
     : num_failed_recreate_attempts_(0),
       widget_(widget),
       compositor_deps_(compositor_deps),
       never_visible_(false),
       layout_and_paint_async_callback_(nullptr),
+      remote_proto_channel_receiver_(nullptr),
       weak_factory_(this) {
 }
 
 void RenderWidgetCompositor::Initialize() {
   base::CommandLine* cmd = base::CommandLine::ForCurrentProcess();
 
   cc::LayerTreeSettings settings;
 
   // For web contents, layer transforms should scale up the contents of layers
   // to keep content always crisp when possible.
@@ skipping 733 matching lines @@
 }
 
 void RenderWidgetCompositor::DidPostSwapBuffers() {
   widget_->OnSwapBuffersPosted();
 }
 
 void RenderWidgetCompositor::DidAbortSwapBuffers() {
   widget_->OnSwapBuffersAborted();
 }
 
+void RenderWidgetCompositor::SetProtoReceiver(ProtoReceiver* receiver) {
+  remote_proto_channel_receiver_ = receiver;
+}
+
+void RenderWidgetCompositor::SendCompositorProto(
+    const cc::proto::CompositorMessage& proto) {
+  size_t size = base::checked_cast<size_t>(proto.ByteSize());
+  std::vector<uint8_t> serialized(size);
+  proto.SerializeToArray(serialized.data(), serialized.size());

[David Trainor- moved to gerrit, 2015/11/17 00:58:34]

Hmm I should probably make this use proto.ByteSize() as the size of the array. 
I'm assuming the checked_cast will kill this if anything bad could happen
though?

[palmer, 2015/11/17 01:25:32]

Yep, checked_cast will CHECK if there is a problem. The way you have written it
here works just fine. If you wanted you could fold line 981 into line 982, but
it doesn't matter.

[David Trainor- moved to gerrit, 2015/11/17 04:52:26]

Ah okay thanks!  I tweaked this a bit to just make sure I'm passing the right
thing to the right method, but I guess I didn't have to.

+  widget_->ForwardCompositorProto(serialized);
+}
+
 void RenderWidgetCompositor::RecordFrameTimingEvents(
     scoped_ptr<cc::FrameTimingTracker::CompositeTimingSet> composite_events,
     scoped_ptr<cc::FrameTimingTracker::MainFrameTimingSet> main_frame_events) {
   for (const auto& composite_event : *composite_events ) {
     int64_t frameId = composite_event.first;
     const std::vector<cc::FrameTimingTracker::CompositeTimingEvent>& events =
         composite_event.second;
     std::vector<blink::WebFrameTimingEvent> webEvents;
     for (size_t i = 0; i < events.size(); ++i) {
       webEvents.push_back(blink::WebFrameTimingEvent(
@@ skipping 17 matching lines @@
     widget_->webwidget()->recordFrameTimingEvent(
         blink::WebWidget::RenderEvent, frameId, webEvents);
   }
 }
 
 void RenderWidgetCompositor::SetSurfaceIdNamespace(
     uint32_t surface_id_namespace) {
   layer_tree_host_->set_surface_id_namespace(surface_id_namespace);
 }
 
+void RenderWidgetCompositor::OnHandleCompositorProto(
+    const std::vector<uint8_t>& proto) {
+  DCHECK(remote_proto_channel_receiver_);
+
+  scoped_ptr<cc::proto::CompositorMessage> deserialized(
+      new cc::proto::CompositorMessage);
+  int size = base::checked_cast<int>(proto.size());
+  if (!deserialized->ParseFromArray(proto.data(), size)) {
+    LOG(ERROR) << "Unable to parse compositor proto.";
+    return;
+  }
+
+  remote_proto_channel_receiver_->OnProtoReceived(deserialized.Pass());
+}
+
 cc::ManagedMemoryPolicy RenderWidgetCompositor::GetGpuMemoryPolicy(
     const cc::ManagedMemoryPolicy& policy) {
   cc::ManagedMemoryPolicy actual = policy;
   actual.bytes_limit_when_visible = 0;
 
   // If the value was overridden on the command line, use the specified value.
   static bool client_hard_limit_bytes_overridden =
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kForceGpuMemAvailableMb);
   if (client_hard_limit_bytes_overridden) {
@@ skipping 66 matching lines @@
 #endif
   return actual;
 }
 
 void RenderWidgetCompositor::SetPaintedDeviceScaleFactor(
     float device_scale) {
   layer_tree_host_->SetPaintedDeviceScaleFactor(device_scale);
 }
 
 }  // namespace content