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

components/cast_channel/cast_transport_unittest.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_transport.h"
+#include "components/cast_channel/cast_transport.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/test/simple_test_clock.h"
-#include "extensions/browser/api/cast_channel/cast_framer.h"
-#include "extensions/browser/api/cast_channel/cast_socket.h"
-#include "extensions/browser/api/cast_channel/cast_test_util.h"
-#include "extensions/browser/api/cast_channel/logger.h"
-#include "extensions/common/api/cast_channel/cast_channel.pb.h"
+#include "components/cast_channel/cast_framer.h"
+#include "components/cast_channel/cast_socket.h"
+#include "components/cast_channel/cast_test_util.h"
+#include "components/cast_channel/logger.h"
+#include "components/cast_channel/proto/cast_channel.pb.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_errors.h"
 #include "net/log/test_net_log.h"
 #include "net/socket/socket.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
 using testing::DoAll;
 using testing::InSequence;
 using testing::Invoke;
 using testing::NotNull;
 using testing::Return;
 using testing::WithArg;
 
-namespace extensions {
-namespace api {
 namespace cast_channel {
 namespace {
 
 const int kChannelId = 0;
 
 // Mockable placeholder for write completion events.
 class CompleteHandler {
  public:
   CompleteHandler() {}
   MOCK_METHOD1(Complete, void(int result));
@@ skipping 185 matching lines @@
   socket_cbs.Pop(serialized_message.size() - 1);
   RunPendingTasks();
   EXPECT_EQ(serialized_message.substr(1, serialized_message.size() - 1),
             output);
 }
 
 TEST_F(CastTransportTest, TestWriteFailureAsync) {
   CompletionQueue socket_cbs;
   CompleteHandler write_handler;
   CastMessage message = CreateCastMessage();
-  EXPECT_CALL(mock_socket_, Write(NotNull(), _, _)).WillOnce(
-      DoAll(EnqueueCallback<2>(&socket_cbs), Return(net::ERR_IO_PENDING)));
+  EXPECT_CALL(mock_socket_, Write(NotNull(), _, _))
+      .WillOnce(
+          DoAll(EnqueueCallback<2>(&socket_cbs), Return(net::ERR_IO_PENDING)));
   EXPECT_CALL(write_handler, Complete(net::ERR_FAILED));
   EXPECT_CALL(*delegate_, OnError(ChannelError::CAST_SOCKET_ERROR));
   transport_->SendMessage(
       message,
       base::Bind(&CompleteHandler::Complete, base::Unretained(&write_handler)));
   RunPendingTasks();
   socket_cbs.Pop(net::ERR_CONNECTION_RESET);
   RunPendingTasks();
   EXPECT_EQ(proto::SOCKET_WRITE, logger_->GetLastErrors(kChannelId).event_type);
   EXPECT_EQ(net::ERR_CONNECTION_RESET,
@@ skipping 220 matching lines @@
 
 TEST_F(CastTransportTest, TestReadCorruptedMessageAsync) {
   CompletionQueue socket_cbs;
 
   CastMessage message = CreateCastMessage();
   std::string serialized_message;
   EXPECT_TRUE(MessageFramer::Serialize(message, &serialized_message));
 
   // Corrupt the serialized message body(set it to X's).
   for (size_t i = MessageFramer::MessageHeader::header_size();
-       i < serialized_message.size();
-       ++i) {
+       i < serialized_message.size(); ++i) {
     serialized_message[i] = 'x';
   }
 
   EXPECT_CALL(*delegate_, Start());
   // Read bytes [0, 3].
   EXPECT_CALL(mock_socket_,
               Read(NotNull(), MessageFramer::MessageHeader::header_size(), _))
       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message),
                       EnqueueCallback<2>(&socket_cbs),
                       Return(net::ERR_IO_PENDING)))
@@ skipping 148 matching lines @@
 }
 
 TEST_F(CastTransportTest, TestReadCorruptedMessageSync) {
   InSequence s;
   CastMessage message = CreateCastMessage();
   std::string serialized_message;
   EXPECT_TRUE(MessageFramer::Serialize(message, &serialized_message));
 
   // Corrupt the serialized message body(set it to X's).
   for (size_t i = MessageFramer::MessageHeader::header_size();
-       i < serialized_message.size();
-       ++i) {
+       i < serialized_message.size(); ++i) {
     serialized_message[i] = 'x';
   }
 
   EXPECT_CALL(*delegate_, Start());
 
   // Read bytes [0, 3].
   EXPECT_CALL(mock_socket_,
               Read(NotNull(), MessageFramer::MessageHeader::header_size(), _))
       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message),
                       Return(MessageFramer::MessageHeader::header_size())))
       .RetiresOnSaturation();
   // Read bytes [4, n].
   EXPECT_CALL(mock_socket_,
               Read(NotNull(),
                    serialized_message.size() -
                        MessageFramer::MessageHeader::header_size(),
                    _))
       .WillOnce(DoAll(FillBufferFromString<0>(serialized_message.substr(
                           MessageFramer::MessageHeader::header_size(),
                           serialized_message.size() -
                               MessageFramer::MessageHeader::header_size() - 1)),
                       Return(serialized_message.size() -
                              MessageFramer::MessageHeader::header_size())))
       .RetiresOnSaturation();
   EXPECT_CALL(*delegate_, OnError(ChannelError::INVALID_MESSAGE));
   transport_->Start();
 }
 }  // namespace cast_channel
-}  // namespace api
-}  // namespace extensions