Delete temporary application file as soon as the application is launched.

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 35 matching lines @@
 //
 // Loaders are owned by DynamicApplicationLoader. DynamicApplicationLoader 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)
 // while the async operation is outstanding.
 class DynamicApplicationLoader::Loader {
  public:
-  Loader(MimeTypeToURLMap* mime_type_to_url,
+  Loader(DynamicServiceRunner::CleanupBehavior cleanup_behavior,
+         MimeTypeToURLMap* mime_type_to_url,
          Context* context,
          DynamicServiceRunnerFactory* runner_factory,
          ScopedMessagePipeHandle shell_handle,
          ApplicationLoader::LoadCallback load_callback,
          const LoaderCompleteCallback& loader_complete_callback)
-      : shell_handle_(shell_handle.Pass()),
+      : cleanup_behavior_(cleanup_behavior),
+        shell_handle_(shell_handle.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) {}
 
   virtual ~Loader() {}
 
  protected:
@@ skipping 32 matching lines @@
 
     // TODO(aa): Sanity check that the thing we got looks vaguely like a mojo
     // application. That could either mean looking for the platform-specific dll
     // header, or looking for some specific mojo signature prepended to the
     // library.
 
     AsPath(context_->task_runners()->blocking_pool(),
            base::Bind(&Loader::RunLibrary, weak_ptr_factory_.GetWeakPtr()));
   }
 
-  virtual void ReportComplete() { loader_complete_callback_.Run(this); }
+  void ReportComplete() { loader_complete_callback_.Run(this); }
 
  private:
   bool PeekContentHandler(std::string* mojo_shebang,
                           GURL* mojo_content_handler_url) {
     std::string shebang;
     if (HasMojoMagic() && PeekFirstLine(&shebang)) {
       GURL url(shebang.substr(arraysize(kMojoMagic) - 1, std::string::npos));
       if (url.is_valid()) {
         *mojo_shebang = shebang;
         *mojo_content_handler_url = url;
         return true;
       }
     }
     return false;
   }
 
   void RunLibrary(const base::FilePath& path, bool path_exists) {
     DCHECK(shell_handle_.is_valid());
 
     if (!path_exists) {
       LOG(ERROR) << "Library not started because library path '" << path.value()
                  << "' does not exist.";
       ReportComplete();
       return;
     }
 
     runner_ = runner_factory_->Create(context_);
     runner_->Start(
-        path, shell_handle_.Pass(),
+        path, cleanup_behavior_, shell_handle_.Pass(),
         base::Bind(&Loader::ReportComplete, weak_ptr_factory_.GetWeakPtr()));
   }
 
+  DynamicServiceRunner::CleanupBehavior cleanup_behavior_;
   ScopedMessagePipeHandle shell_handle_;
   ApplicationLoader::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,
               ScopedMessagePipeHandle shell_handle,
               ApplicationLoader::LoadCallback load_callback,
               const LoaderCompleteCallback& loader_complete_callback)
-      : Loader(mime_type_to_url,
+      : Loader(DynamicServiceRunner::DontDeleteAppPath,
+               mime_type_to_url,
                context,
                runner_factory,
                shell_handle.Pass(),
                load_callback,
                loader_complete_callback),
         url_(url),
         path_(UrlToFile(url)) {
     Load();
   }
 
@@ skipping 67 matching lines @@
 class DynamicApplicationLoader::NetworkLoader : public Loader {
  public:
   NetworkLoader(const GURL& url,
                 NetworkService* network_service,
                 MimeTypeToURLMap* mime_type_to_url,
                 Context* context,
                 DynamicServiceRunnerFactory* runner_factory,
                 ScopedMessagePipeHandle shell_handle,
                 ApplicationLoader::LoadCallback load_callback,
                 const LoaderCompleteCallback& loader_complete_callback)
-      : Loader(mime_type_to_url,
+      : Loader(DynamicServiceRunner::DeleteAppPath,
+               mime_type_to_url,
                context,
                runner_factory,
                shell_handle.Pass(),
                load_callback,
                loader_complete_callback),
         url_(url),
         weak_ptr_factory_(this) {
     StartNetworkRequest(url, network_service);
   }
 
@@ skipping 154 matching lines @@
       LOG(ERROR) << "Error (" << response->error->code << ": "
                  << response->error->description << ") while fetching "
                  << response->url;
       ReportComplete();
       return;
     }
     response_ = response.Pass();
     Load();
   }
 
-  void ReportComplete() override {
-    Loader::ReportComplete();
-    // As soon as we've loaded the library we can delete the cache file.
-    // Tools can read the mojo_shell.PID.maps file to find the original library.
-    if (!path_.empty())
-      DeleteFile(path_, false);
-  }
-
   const GURL url_;
   URLLoaderPtr url_loader_;
   URLResponsePtr response_;
   base::FilePath path_;
   base::WeakPtrFactory<NetworkLoader> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkLoader);
 };
 
 DynamicApplicationLoader::DynamicApplicationLoader(
@@ skipping 47 matching lines @@
   // 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