Move //mojo/shell to //shell

shell/external_application_listener_posix.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/external_application_listener_posix.h"
+#include "shell/external_application_listener_posix.h"
 
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread_checker.h"
 #include "base/tracked_objects.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/edk/embedder/channel_init.h"
 #include "mojo/public/cpp/bindings/error_handler.h"
-#include "mojo/shell/domain_socket/net_errors.h"
-#include "mojo/shell/domain_socket/socket_descriptor.h"
-#include "mojo/shell/external_application_registrar.mojom.h"
-#include "mojo/shell/incoming_connection_listener_posix.h"
+#include "shell/domain_socket/net_errors.h"
+#include "shell/domain_socket/socket_descriptor.h"
+#include "shell/external_application_registrar.mojom.h"
+#include "shell/incoming_connection_listener_posix.h"
 #include "url/gurl.h"
 
 namespace mojo {
 namespace shell {
 
 namespace {
 const char kDefaultListenSocketPath[] = "/var/run/mojo/system_socket";
 }  // namespace
 
 // static
@@ skipping 40 matching lines @@
 }
 
 ExternalApplicationListenerPosix::~ExternalApplicationListenerPosix() {
   DCHECK(register_thread_checker_.CalledOnValidThread());
   weak_ptr_factory_.InvalidateWeakPtrs();
 
   // listener_ needs to be destroyed on io_runner_, and it has to die before
   // this object does, as it holds a pointer back to this instance.
   base::WaitableEvent stop_listening_event(true, false);
   io_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&ExternalApplicationListenerPosix::StopListening,
-                 base::Unretained(this),
-                 &stop_listening_event));
+      FROM_HERE, base::Bind(&ExternalApplicationListenerPosix::StopListening,
+                            base::Unretained(this), &stop_listening_event));
   stop_listening_event.Wait();
 }
 
 void ExternalApplicationListenerPosix::ListenInBackground(
     const base::FilePath& listen_socket_path,
     const RegisterCallback& register_callback) {
   DCHECK(register_thread_checker_.CalledOnValidThread());
-  ListenInBackgroundWithErrorCallback(
-      listen_socket_path, register_callback, ErrorCallback());
+  ListenInBackgroundWithErrorCallback(listen_socket_path, register_callback,
+                                      ErrorCallback());
 }
 
 void ExternalApplicationListenerPosix::ListenInBackgroundWithErrorCallback(
     const base::FilePath& listen_socket_path,
     const RegisterCallback& register_callback,
     const ErrorCallback& error_callback) {
   DCHECK(register_thread_checker_.CalledOnValidThread());
   register_callback_ = register_callback;
   error_callback_ = error_callback;
 
   io_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&ExternalApplicationListenerPosix::StartListening,
-                 base::Unretained(this),
-                 listen_socket_path));
+      FROM_HERE, base::Bind(&ExternalApplicationListenerPosix::StartListening,
+                            base::Unretained(this), listen_socket_path));
 }
 
 void ExternalApplicationListenerPosix::WaitForListening() {
   DCHECK(register_thread_checker_.CalledOnValidThread());
   signal_on_listening_.Wait();
 }
 
 void ExternalApplicationListenerPosix::StartListening(
     const base::FilePath& listen_socket_path) {
   CHECK_EQ(base::MessageLoop::current()->type(), base::MessageLoop::TYPE_IO);
@@ skipping 10 matching lines @@
   event->Signal();
 }
 
 void ExternalApplicationListenerPosix::OnListening(int rv) {
   DCHECK(listener_thread_checker_.CalledOnValidThread());
   signal_on_listening_.Signal();
   shell_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &ExternalApplicationListenerPosix::RunErrorCallbackIfListeningFailed,
-          weak_ptr_factory_.GetWeakPtr(),
-          rv));
+          weak_ptr_factory_.GetWeakPtr(), rv));
 }
 
 void ExternalApplicationListenerPosix::OnConnection(SocketDescriptor incoming) {
   DCHECK(listener_thread_checker_.CalledOnValidThread());
   shell_runner_->PostTask(
       FROM_HERE,
       base::Bind(
           &ExternalApplicationListenerPosix::CreatePipeAndBindToRegistrarImpl,
-          weak_ptr_factory_.GetWeakPtr(),
-          incoming));
+          weak_ptr_factory_.GetWeakPtr(), incoming));
 }
 
 void ExternalApplicationListenerPosix::RunErrorCallbackIfListeningFailed(
     int rv) {
   DCHECK(register_thread_checker_.CalledOnValidThread());
   if (rv != net::OK && !error_callback_.is_null()) {
     error_callback_.Run(rv);
   }
 }
 
@@ skipping 26 matching lines @@
 void ExternalApplicationListenerPosix::RegistrarImpl::Register(
     const String& app_url,
     const mojo::Callback<void(ShellPtr)>& callback) {
   MessagePipe pipe;
   register_callback_.Run(app_url.To<GURL>(), pipe.handle0.Pass());
   callback.Run(MakeProxy<Shell>(pipe.handle1.Pass()));
 }
 
 }  // namespace shell
 }  // namespace mojo