Introduce Sky packaged apps.

sky/viewer/content_handler_impl.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 "sky/viewer/content_handler_impl.h"
 
 #include "base/bind.h"
+#include "base/files/scoped_temp_dir.h"
+#include "mojo/common/data_pipe_utils.h"
 #include "mojo/public/cpp/application/connect.h"
 #include "mojo/public/cpp/bindings/strong_binding.h"
 #include "mojo/public/cpp/utility/run_loop.h"
 #include "mojo/services/network/public/interfaces/network_service.mojom.h"
 #include "sky/viewer/document_view.h"
+#include "third_party/zlib/google/zip_reader.h"
 
 namespace sky {
 
 class SkyApplication : public mojo::Application {
  public:
   SkyApplication(mojo::InterfaceRequest<mojo::Application> application,
                  mojo::URLResponsePtr response)
       : binding_(this, application.Pass()),
-        initial_response_(response.Pass()) {}
+        initial_response_(response.Pass()),
+        is_packaged_application_(false) {}
 
   void Initialize(mojo::ShellPtr shell,
                   mojo::Array<mojo::String> args,
                   const mojo::String& url) override {
     shell_ = shell.Pass();
     mojo::ServiceProviderPtr service_provider;
     shell_->ConnectToApplication("mojo:network_service",
                                  mojo::GetProxy(&service_provider), nullptr);
     mojo::ConnectToService(service_provider.get(), &network_service_);
   }
 
   void AcceptConnection(const mojo::String& requestor_url,
                         mojo::InterfaceRequest<mojo::ServiceProvider> services,
                         mojo::ServiceProviderPtr exposed_services,
                         const mojo::String& url) override {
+    if (url.get().rfind(".mojo") == url.size() - 5) {

[tonyg, 2015/04/14 14:36:57]

Maybe just a TODO in this patch, but it seems like eventually we'll want to do
this in a more robust way than extension.

+      is_packaged_application_ = true;
+    }
     if (initial_response_) {
       OnResponseReceived(mojo::URLLoaderPtr(), services.Pass(),
                          exposed_services.Pass(), initial_response_.Pass());
     } else {
       mojo::URLLoaderPtr loader;
       network_service_->CreateURLLoader(mojo::GetProxy(&loader));
       mojo::URLRequestPtr request(mojo::URLRequest::New());
       request->url = url;
       request->auto_follow_redirects = true;
 
@@ skipping 12 matching lines @@
   void RequestQuit() override {
     mojo::RunLoop::current()->Quit();
   }
 
  private:
   void OnResponseReceived(
       mojo::URLLoaderPtr loader,
       mojo::InterfaceRequest<mojo::ServiceProvider> services,
       mojo::ServiceProviderPtr exposed_services,
       mojo::URLResponsePtr response) {
-    new DocumentView(services.Pass(), exposed_services.Pass(), response.Pass(),
+    mojo::URLResponsePtr entrypoint = mojo::URLResponse::New();
+    if (is_packaged_application_) {
+      CHECK(unpacked_app_directory_.CreateUniqueTempDir());
+      ExtractApplication(response.Pass());
+      base::FilePath package_root = unpacked_app_directory_.path();
+
+      base::FilePath entry_path = package_root.Append("main.sky");

[tonyg, 2015/04/14 14:36:56]

Is it a good idea to enforce the "main.sky" name? Perhaps it is, but I'm just
wondering whether this was done purposefully or for convenience.

+      std::string url = "file://" + entry_path.value();
+      entrypoint->url = url;
+
+      // TODO(blundell): This should use |mojo::common::CopyFromFile()| on a
+      // background thread to do the file read asynchronously.
+      std::string source;
+      if (!base::ReadFileToString(entry_path, &source)) {
+        NOTREACHED();
+        return;
+      }
+      mojo::ScopedDataPipeProducerHandle producer_handle;
+      mojo::CreateDataPipe(NULL, &producer_handle, &entrypoint->body);
+      DCHECK(mojo::common::BlockingCopyFromString(source, producer_handle));
+      producer_handle.reset();
+    } else {
+      entrypoint = response.Pass();
+    }
+
+    new DocumentView(services.Pass(), exposed_services.Pass(),
+                     entrypoint.Pass(),
                      shell_.get());
   }
 
+  // TODO(blundell): The below two functions should be moved into a utility
+  // file somewhere where they can be shared by this file, the Dart content
+  // handler, and the Python content handler.
+  void ExtractApplication(mojo::URLResponsePtr response) {
+    zip::ZipReader reader;
+    const std::string input_data = CopyToString(response->body.Pass());

[tonyg, 2015/04/14 14:36:57]

This seems worthy of a comment about a background thread like you have for
ReadFileToString(). If I'm understanding, the currently implementation would
lock the UI for the duration of the download, right?

+    CHECK(reader.OpenFromString(input_data));

[tonyg, 2015/04/14 14:36:57]

Do we really want to crash upon corrupted .mojo files? Seems like we could fail
more gracefully.

+    base::FilePath temp_dir_path = unpacked_app_directory_.path();
+    while (reader.HasMore()) {
+      CHECK(reader.OpenCurrentEntryInZip());
+      CHECK(reader.ExtractCurrentEntryIntoDirectory(temp_dir_path));
+      CHECK(reader.AdvanceToNextEntry());
+    }
+  }
+
+  std::string CopyToString(mojo::ScopedDataPipeConsumerHandle body) {
+    std::string body_str;
+    bool result = mojo::common::BlockingCopyToString(body.Pass(), &body_str);
+    DCHECK(result);
+    return body_str;
+  }
+
   mojo::StrongBinding<mojo::Application> binding_;
   mojo::ShellPtr shell_;
   mojo::NetworkServicePtr network_service_;
   mojo::URLResponsePtr initial_response_;
+  bool is_packaged_application_;
+  base::ScopedTempDir unpacked_app_directory_;
 };
 
 ContentHandlerImpl::ContentHandlerImpl(
     mojo::InterfaceRequest<mojo::ContentHandler> request)
     : binding_(this, request.Pass()) {
 }
 
 ContentHandlerImpl::~ContentHandlerImpl() {
 }
 
 void ContentHandlerImpl::StartApplication(
     mojo::InterfaceRequest<mojo::Application> application,
     mojo::URLResponsePtr response) {
   new SkyApplication(application.Pass(), response.Pass());
 }
 
 }  // namespace sky