[chrome.cast.channel] Remove event logging.

extensions/browser/api/cast_channel/cast_transport.cc

 // Copyright 2014 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 "extensions/browser/api/cast_channel/cast_transport.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "extensions/browser/api/cast_channel/cast_framer.h"
 #include "extensions/browser/api/cast_channel/cast_message_util.h"
 #include "extensions/browser/api/cast_channel/logger.h"
-#include "extensions/browser/api/cast_channel/logger_util.h"
 #include "extensions/common/api/cast_channel/cast_channel.pb.h"
 #include "net/base/net_errors.h"
 #include "net/socket/socket.h"
 
 #define VLOG_WITH_CONNECTION(level)                                           \
   VLOG(level) << "[" << ip_endpoint_.ToString() << ", auth=" << channel_auth_ \
               << "] "
 
 namespace extensions {
 namespace api {
@@ skipping 128 matching lines @@
         FROM_HERE, base::Bind(callback, net::ERR_FAILED));
     callback.Reset();
   }
 }
 
 void CastTransportImpl::SendMessage(const CastMessage& message,
                                     const net::CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
   std::string serialized_message;
   if (!MessageFramer::Serialize(message, &serialized_message)) {
-    logger_->LogSocketEventForMessage(channel_id_, proto::SEND_MESSAGE_FAILED,
-                                      message.namespace_(),
-                                      "Error when serializing message.");
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, net::ERR_FAILED));
     return;
   }
   WriteRequest write_request(
       message.namespace_(), serialized_message, callback);
 
   write_queue_.push(write_request);
-  logger_->LogSocketEventForMessage(
-      channel_id_, proto::MESSAGE_ENQUEUED, message.namespace_(),
-      base::StringPrintf("Queue size: %" PRIuS, write_queue_.size()));
   if (write_state_ == WRITE_STATE_IDLE) {
     SetWriteState(WRITE_STATE_WRITE);
     OnWriteResult(net::OK);
   }
 }
 
 CastTransportImpl::WriteRequest::WriteRequest(
     const std::string& namespace_,
     const std::string& payload,
     const net::CompletionCallback& callback)
     : message_namespace(namespace_), callback(callback) {
   VLOG(2) << "WriteRequest size: " << payload.size();
   io_buffer = new net::DrainableIOBuffer(new net::StringIOBuffer(payload),
                                          payload.size());
 }
 
 CastTransportImpl::WriteRequest::WriteRequest(const WriteRequest& other) =
     default;
 
 CastTransportImpl::WriteRequest::~WriteRequest() {
 }
 
 void CastTransportImpl::SetReadState(ReadState read_state) {
-  if (read_state_ != read_state) {
+  if (read_state_ != read_state)
     read_state_ = read_state;
-    logger_->LogSocketReadState(channel_id_, ReadStateToProto(read_state_));
-  }
 }
 
 void CastTransportImpl::SetWriteState(WriteState write_state) {
-  if (write_state_ != write_state) {
+  if (write_state_ != write_state)
     write_state_ = write_state;
-    logger_->LogSocketWriteState(channel_id_, WriteStateToProto(write_state_));
-  }
 }
 
 void CastTransportImpl::SetErrorState(ChannelError error_state) {
   VLOG_WITH_CONNECTION(2) << "SetErrorState: " << error_state;
   error_state_ = error_state;
 }
 
 void CastTransportImpl::OnWriteResult(int result) {
   DCHECK(CalledOnValidThread());
   DCHECK_NE(WRITE_STATE_IDLE, write_state_);
@@ skipping 30 matching lines @@
         break;
       default:
         NOTREACHED() << "Unknown state in write state machine: " << state;
         SetWriteState(WRITE_STATE_ERROR);
         SetErrorState(CHANNEL_ERROR_UNKNOWN);
         rv = net::ERR_FAILED;
         break;
     }
   } while (rv != net::ERR_IO_PENDING && !IsTerminalWriteState(write_state_));
 
-  if (IsTerminalWriteState(write_state_)) {
-    logger_->LogSocketWriteState(channel_id_, WriteStateToProto(write_state_));
-
-    if (write_state_ == WRITE_STATE_ERROR) {
-      FlushWriteQueue();
-      DCHECK_NE(CHANNEL_ERROR_NONE, error_state_);
-      VLOG_WITH_CONNECTION(2) << "Sending OnError().";
-      delegate_->OnError(error_state_);
-    }
+  if (write_state_ == WRITE_STATE_ERROR) {
+    FlushWriteQueue();
+    DCHECK_NE(CHANNEL_ERROR_NONE, error_state_);
+    VLOG_WITH_CONNECTION(2) << "Sending OnError().";
+    delegate_->OnError(error_state_);
   }
 }
 
 int CastTransportImpl::DoWrite() {
   DCHECK(!write_queue_.empty());
   WriteRequest& request = write_queue_.front();
 
   VLOG_WITH_CONNECTION(2) << "WriteData byte_count = "
                           << request.io_buffer->size() << " bytes_written "
                           << request.io_buffer->BytesConsumed();
 
   SetWriteState(WRITE_STATE_WRITE_COMPLETE);
 
   int rv = socket_->Write(
       request.io_buffer.get(), request.io_buffer->BytesRemaining(),
       base::Bind(&CastTransportImpl::OnWriteResult, base::Unretained(this)));
   return rv;
 }
 
 int CastTransportImpl::DoWriteComplete(int result) {
   VLOG_WITH_CONNECTION(2) << "DoWriteComplete result=" << result;
   DCHECK(!write_queue_.empty());
-  logger_->LogSocketEventWithRv(channel_id_, proto::SOCKET_WRITE, result);
   if (result <= 0) {  // NOTE that 0 also indicates an error
+    logger_->LogSocketEventWithRv(channel_id_, proto::SOCKET_WRITE, result);
     SetErrorState(CHANNEL_ERROR_SOCKET_ERROR);
     SetWriteState(WRITE_STATE_HANDLE_ERROR);
     return result == 0 ? net::ERR_FAILED : result;
   }
 
   // Some bytes were successfully written
   WriteRequest& request = write_queue_.front();
   scoped_refptr<net::DrainableIOBuffer> io_buffer = request.io_buffer;
   io_buffer->DidConsume(result);
   if (io_buffer->BytesRemaining() == 0) {  // Message fully sent
     SetWriteState(WRITE_STATE_DO_CALLBACK);
   } else {
     SetWriteState(WRITE_STATE_WRITE);
   }
 
   return net::OK;
 }
 
 int CastTransportImpl::DoWriteCallback() {
   VLOG_WITH_CONNECTION(2) << "DoWriteCallback";
   DCHECK(!write_queue_.empty());
 
   WriteRequest& request = write_queue_.front();
-  int bytes_consumed = request.io_buffer->BytesConsumed();
-  logger_->LogSocketEventForMessage(
-      channel_id_, proto::MESSAGE_WRITTEN, request.message_namespace,
-      base::StringPrintf("Bytes: %d", bytes_consumed));
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(request.callback, net::OK));
 
   write_queue_.pop();
   if (write_queue_.empty()) {
     SetWriteState(WRITE_STATE_IDLE);
   } else {
     SetWriteState(WRITE_STATE_WRITE);
   }
 
@@ skipping 52 matching lines @@
         NOTREACHED() << "Unknown state in read state machine: " << state;
         SetReadState(READ_STATE_ERROR);
         SetErrorState(CHANNEL_ERROR_UNKNOWN);
         rv = net::ERR_FAILED;
         break;
     }
   } while (rv != net::ERR_IO_PENDING && !IsTerminalReadState(read_state_));
 
   if (IsTerminalReadState(read_state_)) {
     DCHECK_EQ(READ_STATE_ERROR, read_state_);
-    logger_->LogSocketReadState(channel_id_, ReadStateToProto(read_state_));
     VLOG_WITH_CONNECTION(2) << "Sending OnError().";
     delegate_->OnError(error_state_);
   }
 }
 
 int CastTransportImpl::DoRead() {
   VLOG_WITH_CONNECTION(2) << "DoRead";
   SetReadState(READ_STATE_READ_COMPLETE);
 
   // Determine how many bytes need to be read.
   size_t num_bytes_to_read = framer_->BytesRequested();
   DCHECK_GT(num_bytes_to_read, 0u);
 
   // Read up to num_bytes_to_read into |current_read_buffer_|.
   return socket_->Read(
       read_buffer_.get(), base::checked_cast<uint32_t>(num_bytes_to_read),
       base::Bind(&CastTransportImpl::OnReadResult, base::Unretained(this)));
 }
 
 int CastTransportImpl::DoReadComplete(int result) {
   VLOG_WITH_CONNECTION(2) << "DoReadComplete result = " << result;
-  logger_->LogSocketEventWithRv(channel_id_, proto::SOCKET_READ, result);
   if (result <= 0) {
+    logger_->LogSocketEventWithRv(channel_id_, proto::SOCKET_READ, result);
     VLOG_WITH_CONNECTION(1) << "Read error, peer closed the socket.";
     SetErrorState(CHANNEL_ERROR_SOCKET_ERROR);
     SetReadState(READ_STATE_HANDLE_ERROR);
     return result == 0 ? net::ERR_FAILED : result;
   }
 
   size_t message_size;
   DCHECK(!current_message_);
   ChannelError framing_error;
   current_message_ = framer_->Ingest(result, &message_size, &framing_error);
   if (current_message_.get() && (framing_error == CHANNEL_ERROR_NONE)) {
     DCHECK_GT(message_size, static_cast<size_t>(0));
-    logger_->LogSocketEventForMessage(
-        channel_id_, proto::MESSAGE_READ, current_message_->namespace_(),
-        base::StringPrintf("Message size: %u",
-                           static_cast<uint32_t>(message_size)));
     SetReadState(READ_STATE_DO_CALLBACK);
   } else if (framing_error != CHANNEL_ERROR_NONE) {
     DCHECK(!current_message_);
     SetErrorState(CHANNEL_ERROR_INVALID_MESSAGE);
     SetReadState(READ_STATE_HANDLE_ERROR);
   } else {
     DCHECK(!current_message_);
     SetReadState(READ_STATE_READ);
   }
   return net::OK;
@@ skipping 16 matching lines @@
   VLOG_WITH_CONNECTION(2) << "DoReadHandleError";
   DCHECK_NE(CHANNEL_ERROR_NONE, error_state_);
   DCHECK_LE(result, 0);
   SetReadState(READ_STATE_ERROR);
   return net::ERR_FAILED;
 }
 
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions