Move shell interfaces into the shell.mojom namespace.

mojo/shell/application_manager.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/application_manager.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 111 matching lines @@
 
 ApplicationInstance* ApplicationManager::GetApplicationInstance(
     const Identity& identity) const {
   const auto& it = identity_to_instance_.find(identity);
   return it != identity_to_instance_.end() ? it->second : nullptr;
 }
 
 void ApplicationManager::CreateInstanceForHandle(
     ScopedHandle channel,
     const GURL& url,
-    CapabilityFilterPtr filter,
+    mojom::CapabilityFilterPtr filter,
     InterfaceRequest<mojom::PIDReceiver> pid_receiver) {
   // Instances created by others are considered unique, and thus have no
   // identity. As such they cannot be connected to by anyone else, and so we
   // never call ConnectToClient().
   // TODO(beng): GetPermissiveCapabilityFilter() here obviously cannot make it
   //             to production. See note in application_manager.mojom.
   //             http://crbug.com/555392
   CapabilityFilter local_filter = filter->filter.To<CapabilityFilter>();
   Identity target_id(url, std::string(), local_filter);
   ApplicationInstance* instance = nullptr;
-  InterfaceRequest<Application> application_request =
+  InterfaceRequest<mojom::Application> application_request =
       CreateInstance(target_id, base::Closure(), &instance);
   instance->BindPIDReceiver(std::move(pid_receiver));
   scoped_ptr<NativeRunner> runner =
       native_runner_factory_->Create(base::FilePath());
   runner->InitHost(std::move(channel), std::move(application_request));
   instance->SetNativeRunner(runner.get());
   native_runners_.push_back(std::move(runner));
 }
 
 void ApplicationManager::AddListener(
@@ skipping 14 matching lines @@
       instance.second->set_pid(pid);
       break;
     }
   }
   listeners_.ForAllPtrs(
       [this, id, pid](mojom::ApplicationManagerListener* listener) {
         listener->ApplicationPIDAvailable(id, pid);
       });
 }
 
-InterfaceRequest<Application> ApplicationManager::CreateAndConnectToInstance(
-    scoped_ptr<ConnectToApplicationParams> params,
-    ApplicationInstance** resulting_instance) {
+InterfaceRequest<mojom::Application>
+    ApplicationManager::CreateAndConnectToInstance(
+        scoped_ptr<ConnectToApplicationParams> params,
+        ApplicationInstance** resulting_instance) {
   ApplicationInstance* instance = nullptr;
-  InterfaceRequest<Application> application_request =
+  InterfaceRequest<mojom::Application> application_request =
       CreateInstance(params->target(), params->on_application_end(), &instance);
   instance->ConnectToClient(std::move(params));
   if (resulting_instance)
     *resulting_instance = instance;
   return application_request;
 }
 
-InterfaceRequest<Application> ApplicationManager::CreateInstance(
+InterfaceRequest<mojom::Application> ApplicationManager::CreateInstance(
     const Identity& target_id,
     const base::Closure& on_application_end,
     ApplicationInstance** resulting_instance) {
-  ApplicationPtr application;
-  InterfaceRequest<Application> application_request = GetProxy(&application);
+  mojom::ApplicationPtr application;
+  InterfaceRequest<mojom::Application> application_request =
+      GetProxy(&application);
   ApplicationInstance* instance = new ApplicationInstance(
-      std::move(application), this, target_id, Shell::kInvalidApplicationID,
-      on_application_end);
+      std::move(application), this, target_id,
+      mojom::Shell::kInvalidApplicationID, on_application_end);
   DCHECK(identity_to_instance_.find(target_id) ==
          identity_to_instance_.end());
   identity_to_instance_[target_id] = instance;
   mojom::ApplicationInfoPtr application_info =
       CreateApplicationInfoForInstance(instance);
   listeners_.ForAllPtrs(
       [this, &application_info](mojom::ApplicationManagerListener* listener) {
         listener->ApplicationInstanceCreated(application_info.Clone());
       });
   instance->InitializeApplication();
   if (resulting_instance)
     *resulting_instance = instance;
   return application_request;
 }
 
 void ApplicationManager::HandleFetchCallback(
     scoped_ptr<ConnectToApplicationParams> params,
     scoped_ptr<Fetcher> fetcher) {
   if (!fetcher) {
     // Network error. Drop |params| to tell the requestor.
-    params->connect_callback().Run(Shell::kInvalidApplicationID,
-                                   Shell::kInvalidApplicationID);
+    params->connect_callback().Run(mojom::Shell::kInvalidApplicationID,
+                                   mojom::Shell::kInvalidApplicationID);
     return;
   }
 
   GURL redirect_url = fetcher->GetRedirectURL();
   if (!redirect_url.is_empty()) {
     // And around we go again... Whee!
     // TODO(sky): this loses the original URL info.
     URLRequestPtr new_request = URLRequest::New();
     new_request->url = redirect_url.spec();
     HttpHeaderPtr header = HttpHeader::New();
     header->name = "Referer";
     header->value = fetcher->GetRedirectReferer().spec();
     new_request->headers.push_back(std::move(header));
     params->SetTargetURLRequest(std::move(new_request));
     ConnectToApplication(std::move(params));
     return;
   }
 
   // We already checked if the application was running before we fetched it, but
   // it might have started while the fetch was outstanding. We don't want to
   // have two copies of the app running, so check again.
   if (ConnectToRunningApplication(&params))
     return;
 
   Identity source = params->source();
   Identity target = params->target();
-  Shell::ConnectToApplicationCallback connect_callback =
+  mojom::Shell::ConnectToApplicationCallback connect_callback =
       params->connect_callback();
   params->set_connect_callback(EmptyConnectCallback());
   ApplicationInstance* app = nullptr;
-  InterfaceRequest<Application> request(
+  InterfaceRequest<mojom::Application> request(
       CreateAndConnectToInstance(std::move(params), &app));
 
   uint32_t content_handler_id = package_manager_->HandleWithContentHandler(
       fetcher.get(), source, target.url(), target.filter(), &request);
-  if (content_handler_id != Shell::kInvalidApplicationID) {
+  if (content_handler_id != mojom::Shell::kInvalidApplicationID) {
     app->set_requesting_content_handler_id(content_handler_id);
     connect_callback.Run(app->id(), content_handler_id);
     return;
   }
 
   // TODO(erg): Have a better way of switching the sandbox on. For now, switch
   // it on hard coded when we're using some of the sandboxable core services.
   bool start_sandboxed = false;
   if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kMojoNoSandbox)) {
     start_sandboxed = (target.url() == GURL("mojo://core_services/") &&
                           target.qualifier() == "Core") ||
                       target.url() == GURL("mojo://html_viewer/");
   }
 
-  connect_callback.Run(app->id(), Shell::kInvalidApplicationID);
+  connect_callback.Run(app->id(), mojom::Shell::kInvalidApplicationID);
 
   fetcher->AsPath(
       task_runner_,
       base::Bind(&ApplicationManager::RunNativeApplication,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(std::move(request)), start_sandboxed,
                  base::Passed(std::move(fetcher)), base::Unretained(app)));
 }
 
 void ApplicationManager::RunNativeApplication(
-    InterfaceRequest<Application> application_request,
+    InterfaceRequest<mojom::Application> application_request,
     bool start_sandboxed,
     scoped_ptr<Fetcher> fetcher,
     ApplicationInstance* instance,
     const base::FilePath& path,
     bool path_exists) {
   // We only passed fetcher to keep it alive. Done with it now.
   fetcher.reset();
 
   DCHECK(application_request.is_pending());
 
@@ skipping 66 matching lines @@
 
 void ApplicationManager::CleanupRunner(NativeRunner* runner) {
   for (auto it = native_runners_.begin(); it != native_runners_.end(); ++it) {
     if (it->get() == runner) {
       native_runners_.erase(it);
       return;
     }
   }
 }
 
-Shell::ConnectToApplicationCallback EmptyConnectCallback() {
+mojom::Shell::ConnectToApplicationCallback EmptyConnectCallback() {
   return base::Bind(&OnEmptyOnConnectCallback);
 }
 
 }  // namespace shell
 }  // namespace mojo