Simplify the ApplicationLoader interface in preparation for changes.

shell/dynamic_application_loader.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/dynamic_application_loader.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
@@ skipping 42 matching lines @@
 // Async operations are done with WeakPtr to protect against
 // DynamicApplicationLoader going away (and taking all the Loaders with it)
 // while the async operation is outstanding.
 class DynamicApplicationLoader::Loader {
  public:
   Loader(DynamicServiceRunner::CleanupBehavior cleanup_behavior,
          MimeTypeToURLMap* mime_type_to_url,
          Context* context,
          DynamicServiceRunnerFactory* runner_factory,
          InterfaceRequest<Application> application_request,
-         ApplicationLoader::LoadCallback load_callback,
+         LoadCallback load_callback,
          const LoaderCompleteCallback& loader_complete_callback)
       : cleanup_behavior_(cleanup_behavior),
         application_request_(application_request.Pass()),
         load_callback_(load_callback),
         loader_complete_callback_(loader_complete_callback),
         context_(context),
         mime_type_to_url_(mime_type_to_url),
         runner_factory_(runner_factory),
         weak_ptr_factory_(this) {}
 
@@ skipping 70 matching lines @@
     }
 
     runner_ = runner_factory_->Create(context_);
     runner_->Start(
         path, cleanup_behavior_, application_request_.Pass(),
         base::Bind(&Loader::ReportComplete, weak_ptr_factory_.GetWeakPtr()));
   }
 
   DynamicServiceRunner::CleanupBehavior cleanup_behavior_;
   InterfaceRequest<Application> application_request_;
-  ApplicationLoader::LoadCallback load_callback_;
+  LoadCallback load_callback_;
   LoaderCompleteCallback loader_complete_callback_;
   Context* context_;
   MimeTypeToURLMap* mime_type_to_url_;
   DynamicServiceRunnerFactory* runner_factory_;
   scoped_ptr<DynamicServiceRunner> runner_;
   base::WeakPtrFactory<Loader> weak_ptr_factory_;
 };
 
 // A loader for local files.
 class DynamicApplicationLoader::LocalLoader : public Loader {
  public:
   LocalLoader(const GURL& url,
               MimeTypeToURLMap* mime_type_to_url,
               Context* context,
               DynamicServiceRunnerFactory* runner_factory,
               InterfaceRequest<Application> application_request,
-              ApplicationLoader::LoadCallback load_callback,
+              LoadCallback load_callback,
               const LoaderCompleteCallback& loader_complete_callback)
       : Loader(DynamicServiceRunner::DontDeleteAppPath,
                mime_type_to_url,
                context,
                runner_factory,
                application_request.Pass(),
                load_callback,
                loader_complete_callback),
         url_(url),
         path_(UrlToFile(url)) {
@@ skipping 68 matching lines @@
 
 // A loader for network files.
 class DynamicApplicationLoader::NetworkLoader : public Loader {
  public:
   NetworkLoader(const GURL& url,
                 NetworkService* network_service,
                 MimeTypeToURLMap* mime_type_to_url,
                 Context* context,
                 DynamicServiceRunnerFactory* runner_factory,
                 InterfaceRequest<Application> application_request,
-                ApplicationLoader::LoadCallback load_callback,
+                LoadCallback load_callback,
                 const LoaderCompleteCallback& loader_complete_callback)
       : Loader(DynamicServiceRunner::DeleteAppPath,
                mime_type_to_url,
                context,
                runner_factory,
                application_request.Pass(),
                load_callback,
                loader_complete_callback),
         url_(url),
         weak_ptr_factory_(this) {
@@ skipping 192 matching lines @@
 
 void DynamicApplicationLoader::RegisterContentHandler(
     const std::string& mime_type,
     const GURL& content_handler_url) {
   DCHECK(content_handler_url.is_valid())
       << "Content handler URL is invalid for mime type " << mime_type;
   mime_type_to_url_[mime_type] = content_handler_url;
 }
 
 void DynamicApplicationLoader::Load(
-    ApplicationManager* manager,
     const GURL& url,
     InterfaceRequest<Application> application_request,
     LoadCallback load_callback) {
   if (url.SchemeIsFile()) {
     loaders_.push_back(new LocalLoader(
         url, &mime_type_to_url_, context_, runner_factory_.get(),
         application_request.Pass(), load_callback, loader_complete_callback_));
     return;
   }
 
   if (!network_service_) {
     context_->application_manager()->ConnectToService(
         GURL("mojo:network_service"), &network_service_);
   }
 
   loaders_.push_back(new NetworkLoader(
       url, network_service_.get(), &mime_type_to_url_, context_,
       runner_factory_.get(), application_request.Pass(), load_callback,
       loader_complete_callback_));
 }
 
-void DynamicApplicationLoader::OnApplicationError(ApplicationManager* manager,
-                                                  const GURL& url) {
-  // TODO(darin): What should we do about service errors? This implies that
-  // the app closed its handle to the service manager. Maybe we don't care?
-}
-
 void DynamicApplicationLoader::LoaderComplete(Loader* loader) {
   loaders_.erase(std::find(loaders_.begin(), loaders_.end(), loader));
 }
 
 }  // namespace shell
 }  // namespace mojo