[Cast Channel] Add support for nonce challenge to Cast channel authentication.

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>
@@ skipping 95 matching lines @@
   return true;
 }
 
 CastSocketImpl::CastSocketImpl(const std::string& owner_extension_id,
                                const net::IPEndPoint& ip_endpoint,
                                ChannelAuthType channel_auth,
                                net::NetLog* net_log,
                                const base::TimeDelta& timeout,
                                bool keep_alive,
                                const scoped_refptr<Logger>& logger,
-                               uint64_t device_capabilities)
+                               uint64_t device_capabilities,
+                               const std::string& nonce)
     : CastSocket(owner_extension_id),
       owner_extension_id_(owner_extension_id),
       channel_id_(0),
       ip_endpoint_(ip_endpoint),
       channel_auth_(channel_auth),
       net_log_(net_log),
       keep_alive_(keep_alive),
       logger_(logger),
       connect_timeout_(timeout),
       connect_timeout_timer_(new base::OneShotTimer),
       is_canceled_(false),
       device_capabilities_(device_capabilities),
       audio_only_(false),
       connect_state_(proto::CONN_STATE_START_CONNECT),
       error_state_(CHANNEL_ERROR_NONE),
       ready_state_(READY_STATE_NONE),
-      auth_delegate_(nullptr) {
+      auth_delegate_(nullptr),
+      nonce_(nonce) {
   DCHECK(net_log_);
   net_log_source_.type = net::NetLogSourceType::SOCKET;
   net_log_source_.id = net_log_->NextID();
 }
 
 CastSocketImpl::~CastSocketImpl() {
   // Ensure that resources are freed but do not run pending callbacks to avoid
   // any re-entrancy.
   CloseInternal();
 }
@@ skipping 84 matching lines @@
     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_);
+      AuthenticateChallengeReply(*challenge_reply_, *peer_cert_, nonce_);
   logger_->LogSocketChallengeReplyEvent(channel_id_, result);
   if (result.success()) {
     VLOG(1) << result.error_message;
     if (!VerifyChannelPolicy(result)) {
       return false;
     }
   }
   return result.success();
 }
 
@@ skipping 194 matching lines @@
     SetErrorState(CHANNEL_ERROR_AUTHENTICATION_ERROR);
   }
   return result;
 }
 
 int CastSocketImpl::DoAuthChallengeSend() {
   VLOG_WITH_CONNECTION(1) << "DoAuthChallengeSend";
   SetConnectState(proto::CONN_STATE_AUTH_CHALLENGE_SEND_COMPLETE);
 
   CastMessage challenge_message;
-  CreateAuthChallengeMessage(&challenge_message);
+  CreateAuthChallengeMessage(&challenge_message, nonce_);
   VLOG_WITH_CONNECTION(1) << "Sending challenge: "
                           << CastMessageToString(challenge_message);
 
   transport_->SendMessage(
       challenge_message,
       base::Bind(&CastSocketImpl::DoConnectLoop, base::Unretained(this)));
 
   // Always return IO_PENDING since the result is always asynchronous.
   return net::ERR_IO_PENDING;
 }
@@ skipping 151 matching lines @@
   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