Move //mojo/shell to //shell

shell/external_application_listener_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 "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/threading/thread.h"
 #include "mojo/application_manager/application_loader.h"
 #include "mojo/application_manager/application_manager.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/public/interfaces/application/application.mojom.h"
 #include "mojo/public/interfaces/application/service_provider.mojom.h"
 #include "mojo/public/interfaces/application/shell.mojom.h"
-#include "mojo/shell/domain_socket/net_errors.h"
-#include "mojo/shell/domain_socket/test_completion_callback.h"
-#include "mojo/shell/domain_socket/unix_domain_client_socket_posix.h"
-#include "mojo/shell/external_application_listener_posix.h"
-#include "mojo/shell/external_application_registrar.mojom.h"
-#include "mojo/shell/external_application_registrar_connection.h"
+#include "shell/domain_socket/net_errors.h"
+#include "shell/domain_socket/test_completion_callback.h"
+#include "shell/domain_socket/unix_domain_client_socket_posix.h"
+#include "shell/external_application_listener_posix.h"
+#include "shell/external_application_registrar.mojom.h"
+#include "shell/external_application_registrar_connection.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace mojo {
 namespace shell {
 
 class NotAnApplicationLoader : public ApplicationLoader {
  public:
   NotAnApplicationLoader() {}
   ~NotAnApplicationLoader() override {}
@@ skipping 66 matching lines @@
                        base::Closure quit_callback) {
   ExternalApplicationRegistrarConnection connection(socket_path);
   connection.Connect(base::Bind(&QuitLoopOnConnect, to_quit, quit_callback));
 }
 
 }  // namespace
 
 TEST_F(ExternalApplicationListenerTest, ConnectConnection) {
   listener_->ListenInBackground(socket_path_, base::Bind(&DoLocalRegister));
   listener_->WaitForListening();
-  io_thread_.task_runner()->PostTask(FROM_HERE,
-                                     base::Bind(&ConnectOnIOThread,
-                                                socket_path_,
-                                                loop_.task_runner(),
-                                                run_loop_.QuitClosure()));
+  io_thread_.task_runner()->PostTask(
+      FROM_HERE, base::Bind(&ConnectOnIOThread, socket_path_,
+                            loop_.task_runner(), run_loop_.QuitClosure()));
   run_loop_.Run();
 }
 
 namespace {
 
 class QuitLoopOnConnectApplicationImpl : public InterfaceImpl<Application> {
  public:
   QuitLoopOnConnectApplicationImpl(const std::string& url,
                                    scoped_refptr<base::TaskRunner> loop,
                                    base::Closure quit_callback)
@@ skipping 20 matching lines @@
   void ConnectSynchronously(const base::FilePath& socket_path) {
     connection_.reset(new ExternalApplicationRegistrarConnection(socket_path));
     TestCompletionCallback connect_callback;
     connection_->Connect(connect_callback.callback());
     connect_callback.WaitForResult();
   }
 
   // application_impl is the the actual implementation to be registered.
   void Register(scoped_ptr<InterfaceImpl<Application>> application_impl,
                 base::Closure register_complete_callback) {
-    connection_->Register(GURL(url_),
-                          base::Bind(&FakeExternalApplication::OnRegister,
-                                     base::Unretained(this),
-                                     register_complete_callback));
+    connection_->Register(
+        GURL(url_),
+        base::Bind(&FakeExternalApplication::OnRegister, base::Unretained(this),
+                   register_complete_callback));
     application_impl_ = application_impl.Pass();
   }
 
   void ConnectToAppByUrl(std::string app_url) {
     ServiceProviderPtr sp;
     ptr_->ConnectToApplication(app_url, GetProxy(&sp));
   }
 
   const std::string& url() { return url_; }
 
@@ skipping 22 matching lines @@
 void ConnectAndRegisterOnIOThread(const base::FilePath& socket_path,
                                   scoped_refptr<base::TaskRunner> loop,
                                   base::Closure quit_callback,
                                   FakeExternalApplication* connector,
                                   FakeExternalApplication* connectee) {
   // Connect the first app to the registrar.
   connector->ConnectSynchronously(socket_path);
   // connector will use this implementation of the Mojo Application interface
   // once registration complete.
   scoped_ptr<QuitLoopOnConnectApplicationImpl> connector_app_impl(
-      new QuitLoopOnConnectApplicationImpl(
-          connector->url(), loop, quit_callback));
+      new QuitLoopOnConnectApplicationImpl(connector->url(), loop,
+                                           quit_callback));
   // Since connectee won't be ready when connector is done registering, pass
   // in a do-nothing callback.
   connector->Register(connector_app_impl.Pass(), base::Bind(&NoOp));
 
   // Connect the second app to the registrar.
   connectee->ConnectSynchronously(socket_path);
   scoped_ptr<QuitLoopOnConnectApplicationImpl> connectee_app_impl(
-      new QuitLoopOnConnectApplicationImpl(
-          connectee->url(), loop, quit_callback));
+      new QuitLoopOnConnectApplicationImpl(connectee->url(), loop,
+                                           quit_callback));
   // After connectee is successfully registered, connector should be
   // able to connect to is by URL. Pass in a callback to attempt the
   // app -> app connection.
   connectee->Register(connectee_app_impl.Pass(),
                       base::Bind(&ConnectToApp, connector, connectee));
 }
 
 void DestroyOnIOThread(scoped_ptr<FakeExternalApplication> doomed1,
                        scoped_ptr<FakeExternalApplication> doomed2) {
 }
@@ skipping 13 matching lines @@
                                base::Unretained(&application_manager)));
   listener_->WaitForListening();
 
   // Create two external apps.
   scoped_ptr<FakeExternalApplication> supersweet_app(
       new FakeExternalApplication("http://my.supersweet.app"));
   scoped_ptr<FakeExternalApplication> awesome_app(
       new FakeExternalApplication("http://my.awesome.app"));
 
   // Connecting and talking to the registrar has to happen on the IO thread.
-  io_thread_.task_runner()->PostTask(FROM_HERE,
-                                     base::Bind(&ConnectAndRegisterOnIOThread,
-                                                socket_path_,
-                                                loop_.task_runner(),
-                                                run_loop_.QuitClosure(),
-                                                supersweet_app.get(),
-                                                awesome_app.get()));
+  io_thread_.task_runner()->PostTask(
+      FROM_HERE, base::Bind(&ConnectAndRegisterOnIOThread, socket_path_,
+                            loop_.task_runner(), run_loop_.QuitClosure(),
+                            supersweet_app.get(), awesome_app.get()));
   run_loop_.Run();
 
   // The apps need to be destroyed on the thread where they did socket stuff.
-  io_thread_.task_runner()->PostTask(FROM_HERE,
-                                     base::Bind(&DestroyOnIOThread,
-                                                base::Passed(&supersweet_app),
-                                                base::Passed(&awesome_app)));
+  io_thread_.task_runner()->PostTask(
+      FROM_HERE, base::Bind(&DestroyOnIOThread, base::Passed(&supersweet_app),
+                            base::Passed(&awesome_app)));
 }
 
 }  // namespace shell
 }  // namespace mojo