Simplify the ApplicationLoader interface in preparation for changes.

shell/native_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 "shell/native_application_loader.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 23 matching lines @@
 static const char kMojoMagic[] = "#!mojo ";
 static const size_t kMaxShebangLength = 2048;
 
 void IgnoreResult(bool result) {
 }
 
 }  // namespace
 
 // Encapsulates loading and running one individual application.
 //
-// Loaders are owned by DynamicApplicationLoader. DynamicApplicationLoader must
+// Loaders are owned by NativeApplicationLoader. NativeApplicationLoader must
 // ensure that all the parameters passed to Loader subclasses stay valid through
 // Loader's lifetime.
 //
 // Async operations are done with WeakPtr to protect against
-// DynamicApplicationLoader going away (and taking all the Loaders with it)
+// NativeApplicationLoader going away (and taking all the Loaders with it)
 // while the async operation is outstanding.
-class DynamicApplicationLoader::Loader {
+class NativeApplicationLoader::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 {
+class NativeApplicationLoader::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 60 matching lines @@
     return true;
   }
 
   GURL url_;
   base::FilePath path_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalLoader);
 };
 
 // A loader for network files.
-class DynamicApplicationLoader::NetworkLoader : public Loader {
+class NativeApplicationLoader::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 167 matching lines @@
 
   const GURL url_;
   URLLoaderPtr url_loader_;
   URLResponsePtr response_;
   base::FilePath path_;
   base::WeakPtrFactory<NetworkLoader> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkLoader);
 };
 
-DynamicApplicationLoader::DynamicApplicationLoader(
+NativeApplicationLoader::NativeApplicationLoader(
     Context* context,
     scoped_ptr<DynamicServiceRunnerFactory> runner_factory)
     : context_(context),
       runner_factory_(runner_factory.Pass()),
 
-      // Unretained() is correct here because DynamicApplicationLoader owns the
+      // Unretained() is correct here because NativeApplicationLoader owns the
       // loaders that we pass this callback to.
       loader_complete_callback_(
-          base::Bind(&DynamicApplicationLoader::LoaderComplete,
+          base::Bind(&NativeApplicationLoader::LoaderComplete,
                      base::Unretained(this))) {
 }
 
-DynamicApplicationLoader::~DynamicApplicationLoader() {
+NativeApplicationLoader::~NativeApplicationLoader() {
 }
 
-void DynamicApplicationLoader::RegisterContentHandler(
+void NativeApplicationLoader::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,
+void NativeApplicationLoader::Load(
     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) {
+void NativeApplicationLoader::LoaderComplete(Loader* loader) {
   loaders_.erase(std::find(loaders_.begin(), loaders_.end(), loader));
 }
 
 }  // namespace shell
 }  // namespace mojo