Move //mojo/shell to //shell

shell/domain_socket/socket_libevent.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 "mojo/shell/domain_socket/socket_libevent.h"
+#include "shell/domain_socket/socket_libevent.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <netinet/in.h>
 #include <sys/socket.h>
 #include <unistd.h>
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/posix/eintr_wrapper.h"
-#include "mojo/shell/domain_socket/net_errors.h"
+#include "shell/domain_socket/net_errors.h"
 
 namespace mojo {
 namespace shell {
 
 SockaddrStorage::SockaddrStorage(const SockaddrStorage& other)
     : addr_len(other.addr_len),
       addr(reinterpret_cast<struct sockaddr*>(&addr_storage)) {
   memcpy(addr, other.addr, addr_len);
 }
 
@@ skipping 56 matching lines @@
 int SocketLibevent::Open(int address_family) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(kInvalidSocket, socket_fd_);
   DCHECK(address_family == AF_INET || address_family == AF_INET6 ||
          address_family == AF_UNIX);
 
   int socket_type = SOCK_STREAM;
 #ifdef SOCK_NONBLOCK
   socket_type |= SOCK_NONBLOCK;
 #endif
-  socket_fd_ = ::socket(address_family,
-                        socket_type,
+  socket_fd_ = ::socket(address_family, socket_type,
                         address_family == AF_UNIX ? 0 : IPPROTO_TCP);
 #ifndef SOCK_NONBLOCK
   if (SetNonBlocking(socket_fd_) != 0) {
     PLOG(ERROR) << "SetNonBlocking() returned an error, errno=" << errno;
     return net::MapSystemError(errno);
   }
 #endif
   if (socket_fd_ < 0) {
     PLOG(ERROR) << "CreatePlatformSocket() returned an error, errno=" << errno;
     return net::MapSystemError(errno);
@@ skipping 59 matching lines @@
   DCHECK_NE(kInvalidSocket, socket_fd_);
   DCHECK(accept_callback_.is_null());
   DCHECK(socket);
   DCHECK(!callback.is_null());
 
   int rv = DoAccept(socket);
   if (rv != net::ERR_IO_PENDING)
     return rv;
 
   if (!base::MessageLoopForIO::current()->WatchFileDescriptor(
-          socket_fd_,
-          true,
-          base::MessageLoopForIO::WATCH_READ,
-          &accept_socket_watcher_,
-          this)) {
+          socket_fd_, true, base::MessageLoopForIO::WATCH_READ,
+          &accept_socket_watcher_, this)) {
     PLOG(ERROR) << "WatchFileDescriptor failed on accept, errno " << errno;
     return net::MapSystemError(errno);
   }
 
   accept_socket_ = socket;
   accept_callback_ = callback;
   return net::ERR_IO_PENDING;
 }
 
 int SocketLibevent::Connect(const SockaddrStorage& address,
                             const CompletionCallback& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(kInvalidSocket, socket_fd_);
   DCHECK(!waiting_connect_);
   DCHECK(!callback.is_null());
 
   SetPeerAddress(address);
 
   int rv = DoConnect();
   if (rv != net::ERR_IO_PENDING)
     return rv;
 
   if (!base::MessageLoopForIO::current()->WatchFileDescriptor(
-          socket_fd_,
-          true,
-          base::MessageLoopForIO::WATCH_WRITE,
-          &write_socket_watcher_,
-          this)) {
+          socket_fd_, true, base::MessageLoopForIO::WATCH_WRITE,
+          &write_socket_watcher_, this)) {
     PLOG(ERROR) << "WatchFileDescriptor failed on connect, errno " << errno;
     return net::MapSystemError(errno);
   }
 
   write_callback_ = callback;
   waiting_connect_ = true;
   return net::ERR_IO_PENDING;
 }
 
 bool SocketLibevent::IsConnected() const {
@@ skipping 161 matching lines @@
     accept_socket_ = NULL;
     accept_callback_.Reset();
   }
 
   waiting_connect_ = false;
   peer_address_.reset();
 }
 
 }  // namespace shell
 }  // namespace mojo