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_path.h"
 #include "base/files/file_util.h"
@@ skipping 63 matching lines @@
   virtual void AsPath(
       base::TaskRunner* task_runner,
       base::Callback<void(const base::FilePath&, bool)> callback) = 0;
 
   virtual std::string MimeType() = 0;
 
   virtual bool HasMojoMagic() = 0;
 
   virtual bool PeekFirstLine(std::string* line) = 0;
 
+  virtual bool CleanPath() = 0;

[Aaron Boodman, 2015/01/22 19:51:30]

This doesn't appear to ever be answered based on runtime state. It only depends
on what the subclass is. In that case, it seems like the subclass should just
pass a constant to the superclass' constructor.

[qsr, 2015/01/26 09:12:13]

Done.

+
   void Load() {
     // If the response begins with a #!mojo <content-handler-url>, use it.
     GURL url;
     std::string shebang;
     if (PeekContentHandler(&shebang, &url)) {
       load_callback_.Run(
           url, shell_handle_.Pass(),
           AsURLResponse(context_->task_runners()->blocking_pool(),
                         static_cast<int>(shebang.size())));
       return;
@@ skipping 38 matching lines @@
 
     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, CleanPath(), shell_handle_.Pass(),
         base::Bind(&Loader::ReportComplete, weak_ptr_factory_.GetWeakPtr()));
   }
 
   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_;
@@ skipping 74 matching lines @@
   bool PeekFirstLine(std::string* line) override {
     std::string start_of_file;
     ReadFileToString(path_, &start_of_file, kMaxShebangLength);
     size_t return_position = start_of_file.find('\n');
     if (return_position == std::string::npos)
       return false;
     *line = start_of_file.substr(0, return_position + 1);
     return true;
   }
 
+  bool CleanPath() override { return false; }
+
   GURL url_;
   base::FilePath path_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalLoader);
 };
 
 // A loader for network files.
 class DynamicApplicationLoader::NetworkLoader : public Loader {
  public:
   NetworkLoader(const GURL& url,
@@ skipping 85 matching lines @@
     return BlockingPeekNBytes(response_->body.get(), &magic, strlen(kMojoMagic),
                               kPeekTimeout) &&
            magic == kMojoMagic;
   }
 
   bool PeekFirstLine(std::string* line) override {
     return BlockingPeekLine(response_->body.get(), line, kMaxShebangLength,
                             kPeekTimeout);
   }
 
+  bool CleanPath() override { return true; }
+
   void StartNetworkRequest(const GURL& url, NetworkService* network_service) {
     URLRequestPtr request(URLRequest::New());
     request->url = String::From(url);
     request->auto_follow_redirects = true;
 
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kDisableCache)) {
       request->bypass_cache = true;
     }
 
@@ skipping 83 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