[chrome.cast.channel] Remove event logging.

extensions/browser/api/cast_channel/cast_socket.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_socket.h"
 
 #include <stdlib.h>
 #include <string.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/format_macros.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_byteorder.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "extensions/browser/api/cast_channel/cast_auth_util.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/cast_transport.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/address_list.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/net_errors.h"
 #include "net/cert/cert_verifier.h"
 #include "net/cert/cert_verify_result.h"
 #include "net/cert/ct_policy_enforcer.h"
 #include "net/cert/multi_log_ct_verifier.h"
 #include "net/cert/x509_certificate.h"
 #include "net/http/transport_security_state.h"
@@ skipping 162 matching lines @@
   connection->SetSocket(std::move(socket));
   net::HostPortPair host_and_port = net::HostPortPair::FromIPEndPoint(
       ip_endpoint_);
 
   return net::ClientSocketFactory::GetDefaultFactory()->CreateSSLClientSocket(
       std::move(connection), host_and_port, ssl_config, context);
 }
 
 scoped_refptr<net::X509Certificate> CastSocketImpl::ExtractPeerCert() {
   net::SSLInfo ssl_info;
-  if (!socket_->GetSSLInfo(&ssl_info) || !ssl_info.cert.get()) {
+  if (!socket_->GetSSLInfo(&ssl_info) || !ssl_info.cert.get())
     return nullptr;
-  }
-
-  logger_->LogSocketEvent(channel_id_, proto::SSL_INFO_OBTAINED);
 
   return ssl_info.cert;
 }
 
 bool CastSocketImpl::VerifyChannelPolicy(const AuthResult& result) {
   audio_only_ = (result.channel_policies & AuthResult::POLICY_AUDIO_ONLY) != 0;
   if (audio_only_ &&
       (device_capabilities_ & CastDeviceCapability::VIDEO_OUT) != 0) {
     LOG_WITH_CONNECTION(ERROR)
         << "Audio only channel policy enforced for video out capable device";
-    logger_->LogSocketEventWithDetails(
-        channel_id_, proto::CHANNEL_POLICY_ENFORCED, std::string());
     return false;
   }
   return true;
 }
 
 bool CastSocketImpl::VerifyChallengeReply() {
   DCHECK(peer_cert_);
   AuthResult result =
       AuthenticateChallengeReply(*challenge_reply_, *peer_cert_);
   logger_->LogSocketChallengeReplyEvent(channel_id_, result);
@@ skipping 13 matching lines @@
 
 void CastSocketImpl::Connect(std::unique_ptr<CastTransport::Delegate> delegate,
                              base::Callback<void(ChannelError)> callback) {
   DCHECK(CalledOnValidThread());
   VLOG_WITH_CONNECTION(1) << "Connect readyState = " << ready_state_;
   DCHECK_EQ(proto::CONN_STATE_START_CONNECT, connect_state_);
 
   delegate_ = std::move(delegate);
 
   if (ready_state_ != READY_STATE_NONE) {
-    logger_->LogSocketEventWithDetails(
-        channel_id_, proto::CONNECT_FAILED, "ReadyState not NONE");
     callback.Run(CHANNEL_ERROR_CONNECT_ERROR);
     return;
   }
 
   connect_callback_ = callback;
   SetReadyState(READY_STATE_CONNECTING);
   SetConnectState(proto::CONN_STATE_TCP_CONNECT);
 
   // Set up connection timeout.
   if (connect_timeout_.InMicroseconds() > 0) {
     DCHECK(connect_timeout_callback_.IsCancelled());
     connect_timeout_callback_.Reset(
         base::Bind(&CastSocketImpl::OnConnectTimeout, base::Unretained(this)));
     GetTimer()->Start(FROM_HERE,
                       connect_timeout_,
                       connect_timeout_callback_.callback());
   }
 
   DoConnectLoop(net::OK);
 }
 
 CastTransport* CastSocketImpl::transport() const {
   return transport_.get();
 }
 
 void CastSocketImpl::OnConnectTimeout() {
   DCHECK(CalledOnValidThread());
   // Stop all pending connection setup tasks and report back to the client.
   is_canceled_ = true;
-  logger_->LogSocketEvent(channel_id_, proto::CONNECT_TIMED_OUT);
   VLOG_WITH_CONNECTION(1) << "Timeout while establishing a connection.";
   SetErrorState(CHANNEL_ERROR_CONNECT_TIMEOUT);
   DoConnectCallback();
 }
 
 void CastSocketImpl::PostTaskToStartConnectLoop(int result) {
   DCHECK(CalledOnValidThread());
   DCHECK(connect_loop_callback_.IsCancelled());
   connect_loop_callback_.Reset(base::Bind(&CastSocketImpl::DoConnectLoop,
                                           base::Unretained(this), result));
@@ skipping 50 matching lines @@
         SetErrorState(CHANNEL_ERROR_UNKNOWN);
         DoConnectCallback();
         return;
     }
   } while (rv != net::ERR_IO_PENDING && !IsTerminalState(connect_state_));
   // Exit the state machine if an asynchronous network operation is pending
   // or if the state machine is in the terminal "finished" state.
 
   if (IsTerminalState(connect_state_)) {
     DCHECK_NE(rv, net::ERR_IO_PENDING);
-    logger_->LogSocketConnectState(channel_id_, connect_state_);
     GetTimer()->Stop();
     DoConnectCallback();
   } else {
     DCHECK_EQ(rv, net::ERR_IO_PENDING);
   }
 }
 
 int CastSocketImpl::DoTcpConnect() {
   DCHECK(connect_loop_callback_.IsCancelled());
   VLOG_WITH_CONNECTION(1) << "DoTcpConnect";
@@ skipping 116 matching lines @@
 
 void CastSocketImpl::AuthTransportDelegate::OnError(ChannelError error_state) {
   error_state_ = error_state;
   socket_->PostTaskToStartConnectLoop(net::ERR_CONNECTION_FAILED);
 }
 
 void CastSocketImpl::AuthTransportDelegate::OnMessage(
     const CastMessage& message) {
   if (!IsAuthMessage(message)) {
     error_state_ = CHANNEL_ERROR_TRANSPORT_ERROR;
-    socket_->logger_->LogSocketEvent(socket_->channel_id_,
-                                     proto::AUTH_CHALLENGE_REPLY_INVALID);
     socket_->PostTaskToStartConnectLoop(net::ERR_INVALID_RESPONSE);
   } else {
     socket_->challenge_reply_.reset(new CastMessage(message));
-    socket_->logger_->LogSocketEvent(socket_->channel_id_,
-                                     proto::RECEIVED_CHALLENGE_REPLY);
     socket_->PostTaskToStartConnectLoop(net::OK);
   }
 }
 
 void CastSocketImpl::AuthTransportDelegate::Start() {
 }
 
 int CastSocketImpl::DoAuthChallengeReplyComplete(int result) {
   VLOG_WITH_CONNECTION(1) << "DoAuthChallengeReplyComplete: " << result;
 
@@ skipping 60 matching lines @@
   if (GetTimer()) {
     GetTimer()->Stop();
   }
 
   // Cancel callbacks that we queued ourselves to re-enter the connect or read
   // loops.
   connect_loop_callback_.Cancel();
   send_auth_challenge_callback_.Cancel();
   connect_timeout_callback_.Cancel();
   SetReadyState(READY_STATE_CLOSED);
-  logger_->LogSocketEvent(channel_id_, proto::SOCKET_CLOSED);
 }
 
 bool CastSocketImpl::CalledOnValidThread() const {
   return thread_checker_.CalledOnValidThread();
 }
 
 base::Timer* CastSocketImpl::GetTimer() {
   return connect_timeout_timer_.get();
 }
 
 void CastSocketImpl::SetConnectState(proto::ConnectionState connect_state) {
   if (connect_state_ != connect_state) {
     connect_state_ = connect_state;
-    logger_->LogSocketConnectState(channel_id_, connect_state_);
   }
 }
 
 void CastSocketImpl::SetReadyState(ReadyState ready_state) {
-  if (ready_state_ != ready_state) {
+  if (ready_state_ != ready_state)
     ready_state_ = ready_state;
-    logger_->LogSocketReadyState(channel_id_, ReadyStateToProto(ready_state_));
-  }
 }
 
 void CastSocketImpl::SetErrorState(ChannelError error_state) {
   VLOG_WITH_CONNECTION(1) << "SetErrorState " << error_state;
   DCHECK_EQ(CHANNEL_ERROR_NONE, error_state_);
   error_state_ = error_state;
-  logger_->LogSocketErrorState(channel_id_, ErrorStateToProto(error_state_));
   delegate_->OnError(error_state_);
 }
 }  // namespace cast_channel
 }  // namespace api
 }  // namespace extensions
 #undef VLOG_WITH_CONNECTION