blimp: Add logging for compositor and render widget feature.

cc/trees/remote_channel_main.cc

 // Copyright 2016 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/remote_channel_main.h"
 
 #include "base/memory/scoped_ptr.h"
 #include "cc/proto/base_conversions.h"
 #include "cc/proto/compositor_message.pb.h"
 #include "cc/proto/compositor_message_to_impl.pb.h"
@@ skipping 65 matching lines @@
 
 void RemoteChannelMain::SetDeferCommitsOnImpl(bool defer_commits) {
   proto::CompositorMessage proto;
   proto::CompositorMessageToImpl* to_impl_proto = proto.mutable_to_impl();
   to_impl_proto->set_message_type(
       proto::CompositorMessageToImpl::SET_DEFER_COMMITS);
   proto::SetDeferCommits* defer_commits_message =
       to_impl_proto->mutable_defer_commits_message();
   defer_commits_message->set_defer_commits(defer_commits);
 
+  VLOG(1) << "Sending defer commits: " << defer_commits << " to client.";
   SendMessageProto(proto);
 }
 
 void RemoteChannelMain::FinishAllRenderingOnImpl(CompletionEvent* completion) {
   completion->Signal();
 }
 
 void RemoteChannelMain::SetVisibleOnImpl(bool visible) {
   NOTIMPLEMENTED() << "Visibility is not controlled by the server";
 }
@@ skipping 15 matching lines @@
 
 void RemoteChannelMain::SetNeedsRedrawOnImpl(const gfx::Rect& damage_rect) {
   proto::CompositorMessage proto;
   proto::CompositorMessageToImpl* to_impl_proto = proto.mutable_to_impl();
   to_impl_proto->set_message_type(
       proto::CompositorMessageToImpl::SET_NEEDS_REDRAW);
   proto::SetNeedsRedraw* set_needs_redraw_message =
       to_impl_proto->mutable_set_needs_redraw_message();
   RectToProto(damage_rect, set_needs_redraw_message->mutable_damaged_rect());
 
+  VLOG(1) << "Sending redraw request to client.";
   SendMessageProto(proto);
 
   // The client will not inform us when the frame buffers are swapped.
   MainThreadTaskRunner()->PostTask(
       FROM_HERE, base::Bind(&RemoteChannelMain::DidCompleteSwapBuffers,
                             weak_factory_.GetWeakPtr()));
 }
 
 void RemoteChannelMain::SetNeedsCommitOnImpl() {
   proto::CompositorMessage proto;
   proto::CompositorMessageToImpl* to_impl_proto = proto.mutable_to_impl();
   to_impl_proto->set_message_type(
       proto::CompositorMessageToImpl::SET_NEEDS_COMMIT);
 
+  VLOG(1) << "Sending commit request to client.";
   SendMessageProto(proto);
 }
 
 void RemoteChannelMain::BeginMainFrameAbortedOnImpl(
     CommitEarlyOutReason reason,
     base::TimeTicks main_thread_start_time) {
   proto::CompositorMessage proto;
   proto::CompositorMessageToImpl* to_impl_proto = proto.mutable_to_impl();
   to_impl_proto->set_message_type(
       proto::CompositorMessageToImpl::BEGIN_MAIN_FRAME_ABORTED);
   proto::BeginMainFrameAborted* begin_main_frame_aborted_message =
       to_impl_proto->mutable_begin_main_frame_aborted_message();
   CommitEarlyOutReasonToProtobuf(
       reason, begin_main_frame_aborted_message->mutable_reason());
 
+  VLOG(1) << "Sending BeginMainFrameAborted message to client with reason: "
+          << CommitEarlyOutReasonToString(reason);
   SendMessageProto(proto);
 }
 
 void RemoteChannelMain::StartCommitOnImpl(
     CompletionEvent* completion,
     LayerTreeHost* layer_tree_host,
     base::TimeTicks main_thread_start_time,
     bool hold_commit_for_activation) {
   proto::CompositorMessage proto;
   proto::CompositorMessageToImpl* to_impl_proto = proto.mutable_to_impl();
   to_impl_proto->set_message_type(proto::CompositorMessageToImpl::START_COMMIT);
   proto::StartCommit* start_commit_message =
       to_impl_proto->mutable_start_commit_message();
   layer_tree_host->ToProtobufForCommit(
       start_commit_message->mutable_layer_tree_host());
 
+  VLOG(1) << "Sending commit message to client. Commit bytes size: "
+          << proto.ByteSize();
   SendMessageProto(proto);
 
   // In order to avoid incurring the overhead for the client to send us a
   // message for when a frame to be committed is drawn we inform the embedder
   // that the draw was successful immediately after sending the commit message.
   // Since the compositing state may be used by the embedder to throttle
   // commit/draw requests, it is better to allow them to propagate rather than
   // incurring a round-trip to get Acks for draw from the client for each frame.
 
   // This is done as a separate PostTask to ensure that these calls run after
@@ skipping 14 matching lines @@
   proto::CompositorMessage proto;
   proto::CompositorMessageToImpl* to_impl_proto = proto.mutable_to_impl();
   to_impl_proto->set_message_type(
       proto::CompositorMessageToImpl::INITIALIZE_IMPL);
   proto::InitializeImpl* initialize_impl_proto =
       to_impl_proto->mutable_initialize_impl_message();
   proto::LayerTreeSettings* settings_proto =
       initialize_impl_proto->mutable_layer_tree_settings();
   layer_tree_host->settings().ToProtobuf(settings_proto);
 
+  VLOG(1) << "Sending initialize message to client";
   SendMessageProto(proto);
   initialized_ = true;
 }
 
 void RemoteChannelMain::SynchronouslyCloseImpl() {
   DCHECK(initialized_);
   proto::CompositorMessage proto;
   proto::CompositorMessageToImpl* to_impl_proto = proto.mutable_to_impl();
   to_impl_proto->set_message_type(proto::CompositorMessageToImpl::CLOSE_IMPL);
 
+  VLOG(1) << "Sending close message to client.";
   SendMessageProto(proto);
   initialized_ = false;
 }
 
 void RemoteChannelMain::SendMessageProto(
     const proto::CompositorMessage& proto) {
   remote_proto_channel_->SendCompositorProto(proto);
 }
 
 void RemoteChannelMain::HandleProto(
     const proto::CompositorMessageToMain& proto) {
   DCHECK(proto.has_message_type());
 
   switch (proto.message_type()) {
     case proto::CompositorMessageToMain::UNKNOWN:
       NOTIMPLEMENTED() << "Ignoring message proto of unknown type";
       break;
     case proto::CompositorMessageToMain::BEGIN_MAIN_FRAME: {
+      VLOG(1) << "Received BeginMainFrame request from client.";
       const proto::BeginMainFrame& begin_main_frame_message =
           proto.begin_main_frame_message();
       scoped_ptr<BeginMainFrameAndCommitState> begin_main_frame_state;
       begin_main_frame_state.reset(new BeginMainFrameAndCommitState);
       begin_main_frame_state->FromProtobuf(
           begin_main_frame_message.begin_main_frame_state());
       proxy_main_->BeginMainFrame(std::move(begin_main_frame_state));
     } break;
   }
 }
 
 void RemoteChannelMain::DidCommitAndDrawFrame() {
   proxy_main_->DidCommitAndDrawFrame();
   DidCompleteSwapBuffers();
 }
 
 void RemoteChannelMain::DidCompleteSwapBuffers() {
   proxy_main_->DidCompleteSwapBuffers();
 }
 
 base::SingleThreadTaskRunner* RemoteChannelMain::MainThreadTaskRunner() const {
   return task_runner_provider_->MainThreadTaskRunner();
 }
 
 }  // namespace cc