[cast_channel] Move cast_channel related files from //extensions to //components

components/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 "components/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/common/api/cast_channel/cast_channel.pb.h"
+#include "components/cast_channel/cast_auth_util.h"
+#include "components/cast_channel/cast_framer.h"
+#include "components/cast_channel/cast_message_util.h"
+#include "components/cast_channel/cast_transport.h"
+#include "components/cast_channel/logger.h"
+#include "components/cast_channel/proto/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"
 #include "net/log/net_log.h"
 #include "net/log/net_log_source_type.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/client_socket_handle.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/stream_socket.h"
 #include "net/socket/tcp_client_socket.h"
 #include "net/ssl/ssl_config_service.h"
 #include "net/ssl/ssl_info.h"
 
 // Helper for logging data with remote host IP and authentication state.
 // Assumes |ip_endpoint_| of type net::IPEndPoint and |channel_auth_| of enum
 // type ChannelAuthType are available in the current scope.
 #define CONNECTION_INFO()                                                    \
   "[" << ip_endpoint_.ToString()                                             \
       << ", auth=" << ::cast_channel::ChannelAuthTypeToString(channel_auth_) \
       << "] "
 #define VLOG_WITH_CONNECTION(level) VLOG(level) << CONNECTION_INFO()
 #define LOG_WITH_CONNECTION(level) LOG(level) << CONNECTION_INFO()
 
-namespace extensions {
-namespace api {
 namespace cast_channel {
 namespace {
 
 bool IsTerminalState(proto::ConnectionState state) {
   return state == proto::CONN_STATE_FINISHED ||
          state == proto::CONN_STATE_ERROR || state == proto::CONN_STATE_TIMEOUT;
 }
 
 // Cert verifier which blindly accepts all certificates, regardless of validity.
 class FakeCertVerifier : public net::CertVerifier {
@@ skipping 128 matching lines @@
   // Note that |context| fields remain owned by CastSocketImpl.
   net::SSLClientSocketContext context;
   context.cert_verifier = cert_verifier_.get();
   context.transport_security_state = transport_security_state_.get();
   context.cert_transparency_verifier = cert_transparency_verifier_.get();
   context.ct_policy_enforcer = ct_policy_enforcer_.get();
 
   std::unique_ptr<net::ClientSocketHandle> connection(
       new net::ClientSocketHandle);
   connection->SetSocket(std::move(socket));
-  net::HostPortPair host_and_port = net::HostPortPair::FromIPEndPoint(
-      ip_endpoint_);
+  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())
     return nullptr;
 
@@ skipping 25 matching lines @@
   return result.success();
 }
 
 void CastSocketImpl::SetTransportForTesting(
     std::unique_ptr<CastTransport> transport) {
   transport_ = std::move(transport);
 }
 
 void CastSocketImpl::Connect(std::unique_ptr<CastTransport::Delegate> delegate,
                              base::Callback<void(ChannelError)> callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   VLOG_WITH_CONNECTION(1) << "Connect readyState = "
                           << ::cast_channel::ReadyStateToString(ready_state_);
   DCHECK_EQ(proto::CONN_STATE_START_CONNECT, connect_state_);
 
   delegate_ = std::move(delegate);
 
   if (ready_state_ != ReadyState::NONE) {
     callback.Run(ChannelError::CONNECT_ERROR);
     return;
   }
 
   connect_callback_ = callback;
   SetReadyState(ReadyState::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_,
+    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());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   // Stop all pending connection setup tasks and report back to the client.
   is_canceled_ = true;
   VLOG_WITH_CONNECTION(1) << "Timeout while establishing a connection.";
   SetErrorState(ChannelError::CONNECT_TIMEOUT);
   DoConnectCallback();
 }
 
 void CastSocketImpl::ResetConnectLoopCallback() {
   DCHECK(connect_loop_callback_.IsCancelled());
   connect_loop_callback_.Reset(
       base::Bind(&CastSocketImpl::DoConnectLoop, base::Unretained(this)));
 }
 
 void CastSocketImpl::PostTaskToStartConnectLoop(int result) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
   ResetConnectLoopCallback();
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(connect_loop_callback_.callback(), result));
 }
 
 // This method performs the state machine transitions for connection flow.
 // There are two entry points to this method:
 // 1. Connect method: this starts the flow
 // 2. Callback from network operations that finish asynchronously.
@@ skipping 184 matching lines @@
     const CastMessage& message) {
   if (!IsAuthMessage(message)) {
     error_state_ = ChannelError::TRANSPORT_ERROR;
     socket_->PostTaskToStartConnectLoop(net::ERR_INVALID_RESPONSE);
   } else {
     socket_->challenge_reply_.reset(new CastMessage(message));
     socket_->PostTaskToStartConnectLoop(net::OK);
   }
 }
 
-void CastSocketImpl::AuthTransportDelegate::Start() {
-}
+void CastSocketImpl::AuthTransportDelegate::Start() {}
 
 int CastSocketImpl::DoAuthChallengeReplyComplete(int result) {
   VLOG_WITH_CONNECTION(1) << "DoAuthChallengeReplyComplete: " << result;
 
   if (auth_delegate_->error_state() != ChannelError::NONE) {
     SetErrorState(auth_delegate_->error_state());
     SetConnectState(proto::CONN_STATE_ERROR);
     return net::ERR_CONNECTION_FAILED;
   }
   auth_delegate_ = nullptr;
@@ skipping 26 matching lines @@
     SetReadyState(ReadyState::OPEN);
     transport_->SetReadDelegate(std::move(delegate_));
   } else {
     CloseInternal();
   }
 
   base::ResetAndReturn(&connect_callback_).Run(error_state_);
 }
 
 void CastSocketImpl::Close(const net::CompletionCallback& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   CloseInternal();
   // Run this callback last.  It may delete the socket.
   callback.Run(net::OK);
 }
 
 void CastSocketImpl::CloseInternal() {
   // TODO(mfoltz): Enforce this when CastChannelAPITest is rewritten to create
   // and free sockets on the same thread.  crbug.com/398242
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   if (ready_state_ == ReadyState::CLOSED) {
     return;
   }
 
   VLOG_WITH_CONNECTION(1) << "Close ReadyState = "
                           << ::cast_channel::ReadyStateToString(ready_state_);
   transport_.reset();
   tcp_socket_.reset();
   socket_.reset();
   transport_security_state_.reset();
   if (GetTimer()) {
     GetTimer()->Stop();
   }
 
   // Cancel callbacks that we queued ourselves to re-enter the connect or read
   // loops.
   connect_loop_callback_.Cancel();
   connect_timeout_callback_.Cancel();
   SetReadyState(ReadyState::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;
   }
 }
 
 void CastSocketImpl::SetReadyState(ReadyState ready_state) {
   if (ready_state_ != ready_state)
     ready_state_ = ready_state;
 }
 
 void CastSocketImpl::SetErrorState(ChannelError error_state) {
   VLOG_WITH_CONNECTION(1) << "SetErrorState "
                           << ::cast_channel::ChannelErrorToString(error_state);
   DCHECK_EQ(ChannelError::NONE, error_state_);
   error_state_ = error_state;
   delegate_->OnError(error_state_);
 }
 
 }  // namespace cast_channel
-}  // namespace api
-}  // namespace extensions
 #undef VLOG_WITH_CONNECTION