Mojo C++ bindings: Generate InterfaceHandle<> instead of InterfacePtr<>.

shell/application_manager/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 "shell/application_manager/application_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 110 matching lines @@
 }
 
 void ApplicationManager::TerminateShellConnections() {
   identity_to_shell_impl_.clear();
 }
 
 void ApplicationManager::ConnectToApplication(
     const GURL& requested_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
-    ServiceProviderPtr exposed_services,
+    mojo::InterfaceHandle<ServiceProvider> exposed_services,
     const base::Closure& on_application_end) {
   ConnectToApplicationWithParameters(
       requested_url, requestor_url, services.Pass(), exposed_services.Pass(),
       on_application_end, std::vector<std::string>());
 }
 
 void ApplicationManager::ConnectToApplicationWithParameters(
     const GURL& requested_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
-    ServiceProviderPtr exposed_services,
+    mojo::InterfaceHandle<mojo::ServiceProvider> exposed_services,
     const base::Closure& on_application_end,
     const std::vector<std::string>& pre_redirect_parameters) {
   TRACE_EVENT_INSTANT2(
       "mojo_shell", "ApplicationManager::ConnectToApplicationWithParameters",
       TRACE_EVENT_SCOPE_THREAD, "requested_url", requested_url.spec(),
       "requestor_url", requestor_url.spec());
   DCHECK(requested_url.is_valid());
 
   // We check both the mapped and resolved urls for existing shell_impls because
   // external applications can be registered for the unresolved mojo:foo urls.
@@ skipping 83 matching lines @@
 
   new NetworkFetcher(options_.disable_cache, options_.force_offline_by_default,
                      resolved_url, url_response_disk_cache_.get(),
                      network_service, callback);
 }
 
 bool ApplicationManager::ConnectToRunningApplication(
     const GURL& resolved_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider>* services,
-    ServiceProviderPtr* exposed_services) {
+    mojo::InterfaceHandle<mojo::ServiceProvider>* exposed_services) {
   GURL application_url = GetBaseURLAndQuery(resolved_url, nullptr);
   ShellImpl* shell_impl = GetShellImpl(application_url);
   if (!shell_impl)
     return false;
 
   DCHECK(!GetNativeApplicationOptionsForURL(application_url)
               ->new_process_per_connection);
 
   ConnectToClient(shell_impl, resolved_url, requestor_url, services->Pass(),
                   exposed_services->Pass());
   return true;
 }
 
 bool ApplicationManager::ConnectToApplicationWithLoader(
     const GURL& resolved_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider>* services,
-    ServiceProviderPtr* exposed_services,
+    mojo::InterfaceHandle<mojo::ServiceProvider>* exposed_services,
     const base::Closure& on_application_end,
     const std::vector<std::string>& parameters,
     ApplicationLoader* loader) {
   if (!loader)
     return false;
 
   loader->Load(
       resolved_url,
       RegisterShell(resolved_url, requestor_url, services->Pass(),
                     exposed_services->Pass(), on_application_end, parameters));
@@ skipping 10 matching lines @@
           ->new_process_per_connection;
   return new_process_per_connection
              ? Identity(url, base::Uint64ToString(unique_id_number++))
              : Identity(url);
 }
 
 InterfaceRequest<Application> ApplicationManager::RegisterShell(
     const GURL& resolved_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
-    ServiceProviderPtr exposed_services,
+    mojo::InterfaceHandle<mojo::ServiceProvider> exposed_services,
     const base::Closure& on_application_end,
     const std::vector<std::string>& parameters) {
   Identity app_identity = MakeApplicationIdentity(resolved_url);
 
   mojo::ApplicationPtr application;
   InterfaceRequest<Application> application_request =
       mojo::GetProxy(&application);
   ShellImpl* shell =
       new ShellImpl(application.Pass(), this, app_identity, on_application_end);
   identity_to_shell_impl_[app_identity] = make_scoped_ptr(shell);
@@ skipping 12 matching lines @@
   if (shell_it != identity_to_shell_impl_.end())
     return shell_it->second.get();
   return nullptr;
 }
 
 void ApplicationManager::ConnectToClient(
     ShellImpl* shell_impl,
     const GURL& resolved_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
-    ServiceProviderPtr exposed_services) {
+    mojo::InterfaceHandle<mojo::ServiceProvider> exposed_services) {
   shell_impl->ConnectToClient(resolved_url, requestor_url, services.Pass(),
                               exposed_services.Pass());
 }
 
 void ApplicationManager::HandleFetchCallback(
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider> services,
-    ServiceProviderPtr exposed_services,
+    mojo::InterfaceHandle<mojo::ServiceProvider> exposed_services,
     const base::Closure& on_application_end,
     const std::vector<std::string>& parameters,
     scoped_ptr<Fetcher> fetcher) {
   if (!fetcher) {
     // Network error. Drop |application_request| to tell requestor.
     return;
   }
 
   GURL redirect_url = fetcher->GetRedirectURL();
   if (!redirect_url.is_empty()) {
@@ skipping 204 matching lines @@
     return args_it->second;
   return std::vector<std::string>();
 }
 
 void ApplicationManager::CleanupRunner(NativeRunner* runner) {
   native_runners_.erase(
       std::find(native_runners_.begin(), native_runners_.end(), runner));
 }
 
 }  // namespace shell