Two chagnes to cast socket:

chrome/browser/extensions/api/cast_channel/cast_socket.cc

Index: chrome/browser/extensions/api/cast_channel/cast_socket.cc
===================================================================
--- chrome/browser/extensions/api/cast_channel/cast_socket.cc	(revision 250590)
+++ chrome/browser/extensions/api/cast_channel/cast_socket.cc	(working copy)
@@ -71,9 +71,11 @@
     ApiResource(owner_extension_id),
     channel_id_(0),
     url_(url),
+    url_log_str_("[URL: " + url.spec() + "] "),

[Wez, 2014/02/12 21:13:16]

nit: Is "URL:" redundant here?

[mark a. foltz, 2014/02/12 21:45:02]

This is really only for the purposes of logging and doesn't have to do with the
core functionality of the class.  WDYT of defining a macro like VLOG_WITH_URL
instead?

[Wez, 2014/02/12 21:52:14]

+1

[Munjal (Google), 2014/02/12 22:34:36]

Done.

Started doing that but thought I cannot do << syntax in that case. But that is
not the case - macro's text replacement semantics come to the rescue :).

[Munjal (Google), 2014/02/12 22:34:36]

Done.

     delegate_(delegate),
     auth_required_(false),
     current_message_size_(0),
+    current_message_(new CastMessage()),
     net_log_(net_log),
     connect_state_(CONN_STATE_NONE),
     write_state_(WRITE_STATE_NONE),
@@ -145,8 +147,8 @@
   bool result = net::X509Certificate::GetDEREncoded(
      ssl_info.cert->os_cert_handle(), cert);
   if (result)
-    VLOG(1) << "[URL: " << url_.spec()
-            << "] Successfully extracted peer certificate: " << *cert;
+    VLOG(1) << url_log_str_
+            << "Successfully extracted peer certificate: " << *cert;
   return result;
 }
 
@@ -156,7 +158,7 @@
 
 void CastSocket::Connect(const net::CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
-  VLOG(1) << "Connect readyState = " << ready_state_;
+  VLOG(1) << url_log_str_ << "Connect readyState = " << ready_state_;
   if (ready_state_ != READY_STATE_NONE) {
     callback.Run(net::ERR_CONNECTION_FAILED);
     return;
@@ -232,7 +234,7 @@
 }
 
 int CastSocket::DoTcpConnect() {
-  VLOG(1) << "DoTcpConnect";
+  VLOG(1) << url_log_str_ << "DoTcpConnect";
   connect_state_ = CONN_STATE_TCP_CONNECT_COMPLETE;
   tcp_socket_ = CreateTcpSocket();
   return tcp_socket_->Connect(
@@ -240,7 +242,7 @@
 }
 
 int CastSocket::DoTcpConnectComplete(int result) {
-  VLOG(1) << "DoTcpConnectComplete: " << result;
+  VLOG(1) << url_log_str_ << "DoTcpConnectComplete: " << result;
   if (result == net::OK) {
     // Enable TCP protocol-level keep-alive.
     bool result = tcp_socket_->SetKeepAlive(true, kTcpKeepAliveDelaySecs);
@@ -251,7 +253,7 @@
 }
 
 int CastSocket::DoSslConnect() {
-  VLOG(1) << "DoSslConnect";
+  VLOG(1) << url_log_str_ << "DoSslConnect";
   connect_state_ = CONN_STATE_SSL_CONNECT_COMPLETE;
   socket_ = CreateSslSocket(tcp_socket_.PassAs<net::StreamSocket>());
   return socket_->Connect(
@@ -259,7 +261,7 @@
 }
 
 int CastSocket::DoSslConnectComplete(int result) {
-  VLOG(1) << "DoSslConnectComplete: " << result;
+  VLOG(1) << url_log_str_ << "DoSslConnectComplete: " << result;
   if (result == net::ERR_CERT_AUTHORITY_INVALID &&
              peer_cert_.empty() &&
              ExtractPeerCert(&peer_cert_)) {
@@ -271,11 +273,12 @@
 }
 
 int CastSocket::DoAuthChallengeSend() {
-  VLOG(1) << "DoAuthChallengeSend";
+  VLOG(1) << url_log_str_ << "DoAuthChallengeSend";
   connect_state_ = CONN_STATE_AUTH_CHALLENGE_SEND_COMPLETE;
   CastMessage challenge_message;
   CreateAuthChallengeMessage(&challenge_message);
-  VLOG(1) << "Sending challenge: " << CastMessageToString(challenge_message);
+  VLOG(1) << url_log_str_
+          << "Sending challenge: " << CastMessageToString(challenge_message);
   // Post a task to send auth challenge so that DoWriteLoop is not nested inside
   // DoConnectLoop. This is not strictly necessary but keeps the write loop
   // code decoupled from connect loop code.
@@ -289,7 +292,7 @@
 }
 
 int CastSocket::DoAuthChallengeSendComplete(int result) {
-  VLOG(1) << "DoAuthChallengeSendComplete: " << result;
+  VLOG(1) << url_log_str_ << "DoAuthChallengeSendComplete: " << result;
   if (result < 0)
     return result;
   connect_state_ = CONN_STATE_AUTH_CHALLENGE_REPLY_COMPLETE;
@@ -302,12 +305,12 @@
 }
 
 int CastSocket::DoAuthChallengeReplyComplete(int result) {
-  VLOG(1) << "DoAuthChallengeReplyComplete: " << result;
+  VLOG(1) << url_log_str_ << "DoAuthChallengeReplyComplete: " << result;
   if (result < 0)
     return result;
   if (!VerifyChallengeReply())
     return net::ERR_FAILED;
-  VLOG(1) << "Auth challenge verification succeeded";
+  VLOG(1) << url_log_str_ << "Auth challenge verification succeeded";
   return net::OK;
 }
 
@@ -322,7 +325,7 @@
 
 void CastSocket::Close(const net::CompletionCallback& callback) {
   DCHECK(CalledOnValidThread());
-  VLOG(1) << "Close ReadyState = " << ready_state_;
+  VLOG(1) << url_log_str_ << "Close ReadyState = " << ready_state_;
   tcp_socket_.reset();
   socket_.reset();
   cert_verifier_.reset();
@@ -366,7 +369,7 @@
 
 void CastSocket::DoWriteLoop(int result) {
   DCHECK(CalledOnValidThread());
-  VLOG(1) << "WriteData q = " << write_queue_.size();
+  VLOG(1) << url_log_str_ << "DoWriteLoop queue size: " << write_queue_.size();
 
   if (write_queue_.empty()) {
     write_state_ = WRITE_STATE_NONE;
@@ -416,8 +419,9 @@
   DCHECK(!write_queue_.empty());
   WriteRequest& request = write_queue_.front();
 
-  VLOG(1) << "WriteData byte_count = " << request.io_buffer->size()
-           << " bytes_written " << request.io_buffer->BytesConsumed();
+  VLOG(2) << url_log_str_
+          << "WriteData byte_count = " << request.io_buffer->size()
+          << " bytes_written " << request.io_buffer->BytesConsumed();
 
   write_state_ = WRITE_STATE_WRITE_COMPLETE;
 
@@ -564,10 +568,11 @@
 }
 
 int CastSocket::DoReadComplete(int result) {
-  VLOG(1) << "DoReadDataComplete result = " << result
+  VLOG(2) << url_log_str_ << "DoReadComplete result = " << result
           << " header offset = " << header_read_buffer_->offset()
           << " body offset = " << body_read_buffer_->offset();
   if (result <= 0) {  // 0 means EOF: the peer closed the socket
+    VLOG(1) << url_log_str_ << "Read error, peer closed the socket";
     error_state_ = CHANNEL_ERROR_SOCKET_ERROR;
     read_state_ = READ_STATE_ERROR;
     return result == 0 ? net::ERR_FAILED : result;
@@ -603,22 +608,23 @@
 
 int CastSocket::DoReadCallback() {
   read_state_ = READ_STATE_READ;
-  if (IsAuthMessage(current_message_)) {
+  const CastMessage& message = *(current_message_.get());
+  if (IsAuthMessage(message)) {
     // An auth message is received, check that connect flow is running.
     if (ready_state_ == READY_STATE_CONNECTING) {
-      challenge_reply_.reset(new CastMessage(current_message_));
+      challenge_reply_.reset(new CastMessage(message));
       PostTaskToStartConnectLoop(net::OK);
     } else {
       read_state_ = READ_STATE_ERROR;
     }
   } else if (delegate_) {
-    MessageInfo message;
-    if (CastMessageToMessageInfo(current_message_, &message))
-      delegate_->OnMessage(this, message);
+    MessageInfo message_info;
+    if (CastMessageToMessageInfo(message, &message_info))
+      delegate_->OnMessage(this, message_info);
     else
       read_state_ = READ_STATE_ERROR;
   }
-  current_message_.Clear();
+  current_message_->Clear();

[Wez, 2014/02/12 21:13:16]

Rather than clearing & re-using the CastMessage, why not .reset() it here, and
create a new one on each read?

[Munjal (Google), 2014/02/12 22:34:36]

So that we don't create many objects on the heap even though we only need one at
a time. Clear gets the object in the exact same state as creating a new one.

   return net::OK;
 }
 
@@ -641,7 +647,8 @@
   if (header.message_size > kMaxMessageSize)
     return false;
 
-  VLOG(1) << "Parsed header { message_size: " << header.message_size << " }";
+  VLOG(2) << url_log_str_
+          << "Parsed header { message_size: " << header.message_size << " }";
   current_message_size_ = header.message_size;
   return true;
 }
@@ -649,7 +656,7 @@
 bool CastSocket::ProcessBody() {
   DCHECK_EQ(static_cast<uint32>(body_read_buffer_->offset()),
             current_message_size_);
-  if (!current_message_.ParseFromArray(
+  if (!current_message_->ParseFromArray(
       body_read_buffer_->StartOfBuffer(), current_message_size_)) {
     return false;
   }
@@ -686,7 +693,7 @@
 }
 
 bool CastSocket::ParseChannelUrl(const GURL& url) {
-  VLOG(1) << "url = " + url.spec();
+  VLOG(2) << url_log_str_ << "ParseChannelUrl";
   if (url.SchemeIs(kCastInsecureScheme)) {
     auth_required_ = false;
   } else if (url.SchemeIs(kCastSecureScheme)) {
@@ -696,8 +703,8 @@
   }
   // TODO(mfoltz): Manual parsing, yech. Register cast[s] as standard schemes?
   // TODO(mfoltz): Test for IPv6 addresses.  Brackets or no brackets?
-  // TODO(mfoltz): Maybe enforce restriction to IPv4 private and IPv6 link-local
-  // networks

[Wez, 2014/02/12 21:13:16]

Did this need re-wrapping?

[Munjal (Google), 2014/02/12 22:34:36]

Yes, I think it was 81 without wrapping.

+  // TODO(mfoltz): Maybe enforce restriction to IPv4 private and IPv6
+  // link-local networks
   const std::string& path = url.path();
   // Shortest possible: //A:B
   if (path.size() < 5) {
@@ -712,7 +719,7 @@
   }
   const std::string& ip_address_str = path.substr(2, colon - 2);
   const std::string& port_str = path.substr(colon + 1);
-  VLOG(1) << "addr " << ip_address_str << " port " << port_str;
+  VLOG(2) << url_log_str_ << "IP: " << ip_address_str << " Port: " << port_str;
   int port;
   if (!base::StringToInt(port_str, &port))
     return false;