[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 = 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::CastDeviceCapability;
+using ::cast_channel::CastMessage;
+using ::cast_channel::CastSocket;
+using ::cast_channel::CastSocketImpl;
+using ::cast_channel::CastTransport;
+using ::cast_channel::KeepAliveDelegate;
+using ::cast_channel::LastErrors;
+using ::cast_channel::Logger;
 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;
@@ skipping 15 matching lines @@
       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(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)
+  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) {
+      ::cast_channel::proto::CHALLENGE_REPLY_ERROR_NONE) {
     error_info->challenge_reply_error_type.reset(
         new int(last_errors.challenge_reply_error_type));
   }
   if (last_errors.net_return_value <= 0)
     error_info->net_return_value.reset(new int(last_errors.net_return_value));
 }
 
 bool IsValidConnectInfoPort(const ConnectInfo& connect_info) {
   return connect_info.port > 0 && connect_info.port <
     std::numeric_limits<uint16_t>::max();
@@ skipping 62 matching lines @@
 }
 
 CastChannelAPI::~CastChannelAPI() {}
 
 CastChannelAsyncApiFunction::CastChannelAsyncApiFunction()
     : cast_socket_service_(nullptr) {}
 
 CastChannelAsyncApiFunction::~CastChannelAsyncApiFunction() { }
 
 bool CastChannelAsyncApiFunction::PrePrepare() {
-  cast_socket_service_ =
-      api::cast_channel::CastSocketServiceFactory::GetInstance()
-          ->GetForBrowserContext(browser_context());
+  cast_socket_service_ = ::cast_channel::CastSocketServiceFactory::GetInstance()
+                             ->GetForBrowserContext(browser_context());
   DCHECK(cast_socket_service_);
   return true;
 }
 
 bool CastChannelAsyncApiFunction::Respond() {
   return GetError().empty();
 }
 
 CastSocket* CastChannelAsyncApiFunction::GetSocketOrCompleteWithError(
     int channel_id) {
@@ skipping 330 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