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

extensions/browser/api/cast_channel/cast_channel_api.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_channel_api.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
-#include "components/cast_channel/cast_message_util.h"
-#include "components/cast_channel/cast_socket.h"
-#include "components/cast_channel/cast_socket_service.h"
-#include "components/cast_channel/cast_socket_service_factory.h"
-#include "components/cast_channel/keep_alive_delegate.h"
-#include "components/cast_channel/logger.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/api/cast_channel/cast_channel_enum_util.h"
 #include "extensions/browser/api/cast_channel/cast_message_util.h"
+#include "extensions/browser/api/cast_channel/cast_socket.h"
+#include "extensions/browser/api/cast_channel/cast_socket_service.h"
+#include "extensions/browser/api/cast_channel/cast_socket_service_factory.h"
+#include "extensions/browser/api/cast_channel/keep_alive_delegate.h"
+#include "extensions/browser/api/cast_channel/logger.h"
 #include "extensions/browser/event_router.h"
 #include "extensions/common/api/cast_channel/cast_channel.pb.h"
 #include "extensions/common/api/cast_channel/logging.pb.h"
 #include "net/base/ip_address.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_errors.h"
 
 // Default timeout interval for connection setup.
 // Used if not otherwise specified at ConnectInfo::timeout.
 const int kDefaultConnectTimeoutMillis = 5000;  // 5 seconds.
 
 namespace extensions {
 
-namespace Close = api::cast_channel::Close;
-namespace OnError = api::cast_channel::OnError;
-namespace OnMessage = api::cast_channel::OnMessage;
-namespace Open = api::cast_channel::Open;
-namespace Send = api::cast_channel::Send;
-using api::cast_channel::ChannelInfo;
-using api::cast_channel::ConnectInfo;
-using api::cast_channel::ErrorInfo;
-using api::cast_channel::MessageInfo;
-using cast_channel::ChannelError;
+namespace Close = cast_channel::Close;
+namespace OnError = cast_channel::OnError;
+namespace OnMessage = cast_channel::OnMessage;
+namespace Open = cast_channel::Open;
+namespace Send = cast_channel::Send;
+using ::cast_channel::ChannelError;
 using cast_channel::CastDeviceCapability;
 using cast_channel::CastMessage;
 using cast_channel::CastSocket;
 using cast_channel::CastSocketImpl;
 using cast_channel::CastTransport;
+using cast_channel::ChannelInfo;
+using cast_channel::ConnectInfo;
+using cast_channel::ErrorInfo;
 using cast_channel::KeepAliveDelegate;
 using cast_channel::LastErrors;
 using cast_channel::Logger;
-
+using cast_channel::MessageInfo;
 using content::BrowserThread;
 
 namespace {
 
 // T is an extension dictionary (MessageInfo or ChannelInfo)
 template <class T>
 std::string ParamToString(const T& info) {
   std::unique_ptr<base::DictionaryValue> dict = info.ToValue();
   std::string out;
   base::JSONWriter::Write(*dict, &out);
   return out;
 }
 
 // Fills |channel_info| from the destination and state of |socket|.
 void FillChannelInfo(const CastSocket& socket, ChannelInfo* channel_info) {
   DCHECK(channel_info);
   channel_info->channel_id = socket.id();
   const net::IPEndPoint& ip_endpoint = socket.ip_endpoint();
   channel_info->connect_info.ip_address = ip_endpoint.ToStringWithoutPort();
   channel_info->connect_info.port = ip_endpoint.port();
   channel_info->connect_info.auth =
-      api::cast_channel::ToChannelAuthType(socket.channel_auth());
-  channel_info->ready_state =
-      api::cast_channel::ToReadyState(socket.ready_state());
+      cast_channel::ToChannelAuthType(socket.channel_auth());
+  channel_info->ready_state = cast_channel::ToReadyState(socket.ready_state());
   channel_info->error_state =
-      api::cast_channel::ToChannelError(socket.error_state());
+      cast_channel::ToChannelError(socket.error_state());
   channel_info->keep_alive = socket.keep_alive();
   channel_info->audio_only = socket.audio_only();
 }
 
 // Fills |error_info| from |error_state| and |last_errors|.
-void FillErrorInfo(api::cast_channel::ChannelError error_state,
+void FillErrorInfo(cast_channel::ChannelError error_state,
                    const LastErrors& last_errors,
                    ErrorInfo* error_info) {
   error_info->error_state = error_state;
   if (last_errors.event_type != cast_channel::proto::EVENT_TYPE_UNKNOWN)
     error_info->event_type.reset(new int(last_errors.event_type));
   if (last_errors.challenge_reply_error_type !=
       cast_channel::proto::CHALLENGE_REPLY_ERROR_NONE) {
     error_info->challenge_reply_error_type.reset(
         new int(last_errors.challenge_reply_error_type));
   }
@@ skipping 70 matching lines @@
 
 CastChannelAPI::~CastChannelAPI() {}
 
 CastChannelAsyncApiFunction::CastChannelAsyncApiFunction()
     : cast_socket_service_(nullptr) {}
 
 CastChannelAsyncApiFunction::~CastChannelAsyncApiFunction() { }
 
 bool CastChannelAsyncApiFunction::PrePrepare() {
   cast_socket_service_ =
-      cast_channel::CastSocketServiceFactory::GetForBrowserContext(
+      api::cast_channel::CastSocketServiceFactory::GetForBrowserContext(
           browser_context());
   DCHECK(cast_socket_service_);
   return true;
 }
 
 bool CastChannelAsyncApiFunction::Respond() {
   return GetError().empty();
 }
 
 void CastChannelAsyncApiFunction::SetResultFromSocket(
     const CastSocket& socket) {
   ChannelInfo channel_info;
   FillChannelInfo(socket, &channel_info);
-  api::cast_channel::ChannelError error =
-      api::cast_channel::ToChannelError(socket.error_state());
-  if (error != api::cast_channel::CHANNEL_ERROR_NONE) {
+  cast_channel::ChannelError error =
+      cast_channel::ToChannelError(socket.error_state());
+  if (error != cast_channel::CHANNEL_ERROR_NONE) {
     SetError("Channel socket error = " + base::IntToString(error));
   }
   SetResultFromChannelInfo(channel_info);
 }
 
 void CastChannelAsyncApiFunction::SetResultFromError(
     int channel_id,
-    api::cast_channel::ChannelError error) {
+    cast_channel::ChannelError error) {
   ChannelInfo channel_info;
   channel_info.channel_id = channel_id;
-  channel_info.ready_state = api::cast_channel::READY_STATE_CLOSED;
+  channel_info.ready_state = cast_channel::READY_STATE_CLOSED;
   channel_info.error_state = error;
   channel_info.connect_info.ip_address = "";
   channel_info.connect_info.port = 0;
-  channel_info.connect_info.auth =
-      api::cast_channel::CHANNEL_AUTH_TYPE_SSL_VERIFIED;
+  channel_info.connect_info.auth = cast_channel::CHANNEL_AUTH_TYPE_SSL_VERIFIED;
   SetResultFromChannelInfo(channel_info);
   SetError("Channel error = " + base::IntToString(error));
 }
 
 void CastChannelAsyncApiFunction::SetResultFromChannelInfo(
     const ChannelInfo& channel_info) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   SetResult(channel_info.ToValue());
 }
 
@@ skipping 44 matching lines @@
       SetError("livenessTimeout and pingInterval must be set together.");
     } else if (liveness_timeout_ < ping_interval_) {
       SetError("livenessTimeout must be longer than pingTimeout.");
     }
   }
 
   if (!GetError().empty()) {
     return false;
   }
 
-  channel_auth_ =
-      api::cast_channel::ToChannelAuthTypeInternal(connect_info.auth);
+  channel_auth_ = cast_channel::ToChannelAuthTypeInternal(connect_info.auth);
   ip_endpoint_.reset(ParseConnectInfo(connect_info));
   return true;
 }
 
 void CastChannelOpenFunction::AsyncWorkStart() {
   DCHECK(api_);
   DCHECK(ip_endpoint_.get());
   const ConnectInfo& connect_info = params_->connect_info;
   CastSocket* socket;
   std::unique_ptr<CastSocket> test_socket = api_->GetSocketForTest();
@@ skipping 41 matching lines @@
   VLOG(1) << "Connect finished, OnOpen invoked.";
   // TODO: If we failed to open the CastSocket, we may want to clean up here,
   // rather than relying on the extension to call close(). This can be done by
   // calling RemoveSocket() and api_->GetLogger()->ClearLastErrors(channel_id).
   if (result != ChannelError::UNKNOWN) {
     CastSocket* socket = cast_socket_service_->GetSocket(new_channel_id_);
     CHECK(socket);
     SetResultFromSocket(*socket);
   } else {
     // The socket is being destroyed.
-    SetResultFromError(new_channel_id_,
-                       api::cast_channel::CHANNEL_ERROR_UNKNOWN);
+    SetResultFromError(new_channel_id_, cast_channel::CHANNEL_ERROR_UNKNOWN);
   }
 
   AsyncWorkCompleted();
 }
 
 CastChannelSendFunction::CastChannelSendFunction() { }
 
 CastChannelSendFunction::~CastChannelSendFunction() { }
 
 bool CastChannelSendFunction::Prepare() {
@@ skipping 20 matching lines @@
       return false;
   }
   return true;
 }
 
 void CastChannelSendFunction::AsyncWorkStart() {
   CastSocket* socket =
       cast_socket_service_->GetSocket(params_->channel.channel_id);
   if (!socket) {
     SetResultFromError(params_->channel.channel_id,
-                       api::cast_channel::CHANNEL_ERROR_INVALID_CHANNEL_ID);
+                       cast_channel::CHANNEL_ERROR_INVALID_CHANNEL_ID);
     AsyncWorkCompleted();
     return;
   }
   CastMessage message_to_send;
   if (!MessageInfoToCastMessage(params_->message, &message_to_send)) {
     SetResultFromError(params_->channel.channel_id,
-                       api::cast_channel::CHANNEL_ERROR_INVALID_MESSAGE);
+                       cast_channel::CHANNEL_ERROR_INVALID_MESSAGE);
     AsyncWorkCompleted();
     return;
   }
   socket->transport()->SendMessage(
       message_to_send, base::Bind(&CastChannelSendFunction::OnSend, this));
 }
 
 void CastChannelSendFunction::OnSend(int result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   int channel_id = params_->channel.channel_id;
   CastSocket* socket = cast_socket_service_->GetSocket(channel_id);
   if (result < 0 || !socket) {
     SetResultFromError(channel_id,
-                       api::cast_channel::CHANNEL_ERROR_SOCKET_ERROR);
+                       cast_channel::CHANNEL_ERROR_SOCKET_ERROR);
   } else {
     SetResultFromSocket(*socket);
   }
   AsyncWorkCompleted();
 }
 
 CastChannelCloseFunction::CastChannelCloseFunction() { }
 
 CastChannelCloseFunction::~CastChannelCloseFunction() { }
 
 bool CastChannelCloseFunction::PrePrepare() {
   api_ = CastChannelAPI::Get(browser_context());
   return CastChannelAsyncApiFunction::PrePrepare();
 }
 
 bool CastChannelCloseFunction::Prepare() {
   params_ = Close::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void CastChannelCloseFunction::AsyncWorkStart() {
   CastSocket* socket =
       cast_socket_service_->GetSocket(params_->channel.channel_id);
   if (!socket) {
     SetResultFromError(params_->channel.channel_id,
-                       api::cast_channel::CHANNEL_ERROR_INVALID_CHANNEL_ID);
+                       cast_channel::CHANNEL_ERROR_INVALID_CHANNEL_ID);
     AsyncWorkCompleted();
   } else {
     socket->Close(base::Bind(&CastChannelCloseFunction::OnClose, this));
   }
 }
 
 void CastChannelCloseFunction::OnClose(int result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   VLOG(1) << "CastChannelCloseFunction::OnClose result = " << result;
   int channel_id = params_->channel.channel_id;
   CastSocket* socket = cast_socket_service_->GetSocket(channel_id);
   if (result < 0 || !socket) {
     SetResultFromError(channel_id,
-                       api::cast_channel::CHANNEL_ERROR_SOCKET_ERROR);
+                       cast_channel::CHANNEL_ERROR_SOCKET_ERROR);
   } else {
     SetResultFromSocket(*socket);
     // This will delete |socket|.
     cast_socket_service_->RemoveSocket(channel_id);
     api_->GetLogger()->ClearLastErrors(channel_id);
   }
   AsyncWorkCompleted();
 }
 
 CastChannelOpenFunction::CastMessageHandler::CastMessageHandler(
     const EventDispatchCallback& ui_dispatch_cb,
     CastSocket* socket,
     scoped_refptr<Logger> logger)
     : ui_dispatch_cb_(ui_dispatch_cb), socket_(socket), logger_(logger) {
   DCHECK(socket_);
   DCHECK(logger_);
 }
 
 CastChannelOpenFunction::CastMessageHandler::~CastMessageHandler() {
 }
 
 void CastChannelOpenFunction::CastMessageHandler::OnError(
     ChannelError error_state) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   ChannelInfo channel_info;
   FillChannelInfo(*socket_, &channel_info);
-  channel_info.error_state = api::cast_channel::ToChannelError(error_state);
+  channel_info.error_state = cast_channel::ToChannelError(error_state);
   ErrorInfo error_info;
   FillErrorInfo(channel_info.error_state, logger_->GetLastErrors(socket_->id()),
                 &error_info);
 
   std::unique_ptr<base::ListValue> results =
       OnError::Create(channel_info, error_info);
   std::unique_ptr<Event> event(new Event(
       events::CAST_CHANNEL_ON_ERROR, OnError::kEventName, std::move(results)));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
@@ skipping 18 matching lines @@
                                          std::move(results)));
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(ui_dispatch_cb_, base::Passed(std::move(event))));
 }
 
 void CastChannelOpenFunction::CastMessageHandler::Start() {
 }
 
 }  // namespace extensions