[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 46 matching lines @@
 
   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();
 }
 
@@ skipping 211 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 85 matching lines @@
 
 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