Launch nexes from mojo_shell.

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 10 matching lines @@
 #include "base/strings/utf_string_conversions.h"
 #include "crypto/secure_hash.h"
 #include "crypto/sha2.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/common/data_pipe_utils.h"
 #include "mojo/public/cpp/system/data_pipe.h"
 #include "mojo/services/network/public/interfaces/url_loader.mojom.h"
 #include "shell/context.h"
 #include "shell/data_pipe_peek.h"
 #include "shell/filename_util.h"
+#if defined(MOJO_USE_NACL)
+#include "shell/nacl/nacl_service_runner.h"
+#endif
 #include "shell/switches.h"
 #include "url/url_util.h"
 
 namespace mojo {
 namespace shell {
 
 namespace {
 
 static const char kMojoMagic[] = "#!mojo ";
 static const size_t kMaxShebangLength = 2048;
@@ skipping 33 matching lines @@
   virtual ~Loader() {}
 
  protected:
   virtual URLResponsePtr AsURLResponse(base::TaskRunner* task_runner,
                                        uint32_t skip) = 0;
 
   virtual void AsPath(
       base::TaskRunner* task_runner,
       base::Callback<void(const base::FilePath&, bool)> callback) = 0;
 
+  virtual GURL URL() = 0;
+
+  std::string Extension() {
+    std::string filename = URL().ExtractFileName();
+    size_t dot = filename.rfind('.');
+    if (dot != std::string::npos) {
+      return filename.substr(dot);
+    }
+    return "";
+  }
+
   virtual std::string MimeType() = 0;
 
   virtual bool HasMojoMagic() = 0;
 
   virtual bool PeekFirstLine(std::string* line) = 0;
 
   void Load() {
     // If the response begins with a #!mojo <content-handler-url>, use it.
     GURL url;
     std::string shebang;
@@ skipping 11 matching lines @@
           iter->second, application_request_.Pass(),
           AsURLResponse(context_->task_runners()->blocking_pool(), 0));
       return;
     }
 
     // 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.
 
+    // TODO(ncbray) sniff or infer the content type at a previous stage in the
+    // pipeline.
+    if (Extension() == ".nexe") {
+      AsPath(context_->task_runners()->blocking_pool(),
+             base::Bind(&Loader::RunNexe, weak_ptr_factory_.GetWeakPtr()));
+      return;
+    }
+
     AsPath(context_->task_runners()->blocking_pool(),
            base::Bind(&Loader::RunLibrary, weak_ptr_factory_.GetWeakPtr()));
   }
 
   void ReportComplete() { loader_complete_callback_.Run(this); }
 
  private:
   bool PeekContentHandler(std::string* mojo_shebang,
                           GURL* mojo_content_handler_url) {
     std::string shebang;
@@ skipping 17 matching lines @@
       ReportComplete();
       return;
     }
 
     runner_ = runner_factory_->Create(context_);
     runner_->Start(
         path, cleanup_behavior_, application_request_.Pass(),
         base::Bind(&Loader::ReportComplete, weak_ptr_factory_.GetWeakPtr()));
   }
 
+  void RunNexe(const base::FilePath& path, bool path_exists) {
+    DCHECK(application_request_.is_pending());
+
+    if (!path_exists) {
+      LOG(ERROR) << "Library not started because library path '" << path.value()
+                 << "' does not exist.";
+      ReportComplete();
+      return;
+    }
+
+#if defined(MOJO_USE_NACL)
+    nacl_runner_.reset(new NaClServiceRunner(context_));
+    nacl_runner_->Start(path, application_request_.Pass());
+#else
+    LOG(ERROR) << "Library not started because Native Client is not enabled.";
+    ReportComplete();
+#endif
+  }
+
   DynamicServiceRunner::CleanupBehavior cleanup_behavior_;
   InterfaceRequest<Application> application_request_;
   ApplicationLoader::LoadCallback load_callback_;
   LoaderCompleteCallback loader_complete_callback_;
   Context* context_;
   MimeTypeToURLMap* mime_type_to_url_;
   DynamicServiceRunnerFactory* runner_factory_;
   scoped_ptr<DynamicServiceRunner> runner_;
+#if defined(MOJO_USE_NACL)
+  scoped_ptr<NaClServiceRunner> nacl_runner_;
+#endif
   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,
@@ skipping 47 matching lines @@
   }
 
   void AsPath(
       base::TaskRunner* task_runner,
       base::Callback<void(const base::FilePath&, bool)> callback) override {
     // Async for consistency with network case.
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, path_, base::PathExists(path_)));
   }
 
+  GURL URL() override { return url_; }
+
   std::string MimeType() override { return ""; }
 
   bool HasMojoMagic() override {
     std::string magic;
     ReadFileToString(path_, &magic, strlen(kMojoMagic));
     return magic == kMojoMagic;
   }
 
   bool PeekFirstLine(std::string* line) override {
     std::string start_of_file;
@@ skipping 147 matching lines @@
           FROM_HERE, base::Bind(callback, path_, base::PathExists(path_)));
       return;
     }
 
     base::CreateTemporaryFile(&path_);
     common::CopyToFile(response_->body.Pass(), path_, task_runner,
                        base::Bind(&NetworkLoader::CopyCompleted,
                                   weak_ptr_factory_.GetWeakPtr(), callback));
   }
 
+  GURL URL() override { return url_; }
+
   std::string MimeType() override {
     DCHECK(response_);
     return response_->mime_type;
   }
 
   bool HasMojoMagic() override {
     std::string magic;
     return BlockingPeekNBytes(response_->body.get(), &magic, strlen(kMojoMagic),
                               kPeekTimeout) &&
            magic == kMojoMagic;
@@ skipping 93 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