Mojo content handler shebang support

mojo/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 "mojo/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"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "mojo/common/common_type_converters.h"
 #include "mojo/common/data_pipe_utils.h"
 #include "mojo/services/public/interfaces/network/url_loader.mojom.h"
 #include "mojo/shell/context.h"
+#include "mojo/shell/data_pipe_peek.h"
 #include "mojo/shell/filename_util.h"
 #include "mojo/shell/switches.h"
 #include "url/url_util.h"
 
 namespace mojo {
 namespace shell {
 
 // Encapsulates loading and running one individual application.
 //
 // Loaders are owned by DynamicApplicationLoader. DynamicApplicationLoader must
@@ skipping 122 matching lines @@
                        base::Bind(&NetworkLoader::OnLoadComplete,
                                   weak_ptr_factory_.GetWeakPtr()));
   }
 
   ~NetworkLoader() override {
     if (!file_.empty())
       base::DeleteFile(file_, false);
   }
 
  private:
+  bool PeekContentHandler(DataPipeConsumerHandle source,
+                          std::string* mojo_shebang,
+                          GURL* mojo_content_handler_url)
+  {
+    const char* kMojoMagic = "#!mojo:";
+    // TODO(hansmuller): Revisit this when a real peek operation is available.
+    const MojoDeadline kPeekTimeout = MOJO_DEADLINE_INDEFINITE;
+    const size_t kMaxShebangLength = 2048;
+
+    std::string magic;
+    std::string shebang;
+    if (BlockingPeekNBytes(source, &magic, strlen(kMojoMagic), kPeekTimeout) &&
+        magic == kMojoMagic &&
+        BlockingPeekLine(source, &shebang, kMaxShebangLength, kPeekTimeout)) {
+      GURL url(shebang.substr(2, std::string::npos));
+      if (url.is_valid()) {
+        *mojo_shebang = shebang;
+        *mojo_content_handler_url = url;
+        return true;
+      }
+    }
+    return false;
+  }
+
   void OnLoadComplete(URLResponsePtr response) {
     if (response->error) {
       LOG(ERROR) << "Error (" << response->error->code << ": "
                  << response->error->description << ") while fetching "
                  << response->url;
       LoaderComplete();
       return;
     }
 
+    // If the response begins with a #!mojo:<content-handler-url>, use it.
+    {
+      GURL url;
+      std::string shebang;
+      if (PeekContentHandler(response->body.get(), &shebang, &url)) {
+        uint32_t num_skip_bytes = shebang.size();
+        if (ReadDataRaw(response->body.get(),
+                        nullptr,
+                        &num_skip_bytes,
+                        MOJO_READ_DATA_FLAG_ALL_OR_NONE |
+                        MOJO_READ_DATA_FLAG_DISCARD) ==
+            MOJO_RESULT_OK) {
+          load_callbacks_->LoadWithContentHandler(url, response.Pass());
+          return;
+        }
+      }
+    }
+
     MimeTypeToURLMap::iterator iter =
         mime_type_to_url_->find(response->mime_type);
     if (iter != mime_type_to_url_->end()) {
       load_callbacks_->LoadWithContentHandler(iter->second, response.Pass());
       return;
     }
 
-    LOG(INFO) << "Failed to find content handler for " << response->url
-              << " (mimetype: " << response->url << ")" << std::endl
-              << "Attempting to load as native library instead...";
-
-    // TODO(aa): Santify check that the thing we got looks vaguely like a mojo
+    // 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.
 
     base::CreateTemporaryFile(&file_);
     common::CopyToFile(
         response->body.Pass(),
         file_,
         context_->task_runners()->blocking_pool(),
         base::Bind(
             &NetworkLoader::RunLibrary, weak_ptr_factory_.GetWeakPtr(), file_));
   }
 
   MimeTypeToURLMap* mime_type_to_url_;
   URLLoaderPtr url_loader_;
   base::FilePath file_;
   base::WeakPtrFactory<NetworkLoader> weak_ptr_factory_;
 };
-
 DynamicApplicationLoader::DynamicApplicationLoader(
     Context* context,
     scoped_ptr<DynamicServiceRunnerFactory> runner_factory)
     : context_(context),
       runner_factory_(runner_factory.Pass()),
 
       // Unretained() is correct here because DynamicApplicationLoader owns the
       // loaders that we pass this callback to.
       loader_complete_callback_(
           base::Bind(&DynamicApplicationLoader::LoaderComplete,
@@ skipping 48 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