Gets mandoline working on android

components/html_viewer/html_viewer.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 "base/command_line.h"
 #include "base/i18n/icu_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread.h"
 #include "components/html_viewer/blink_platform_impl.h"
 #include "components/html_viewer/discardable_memory_allocator.h"
 #include "components/html_viewer/html_document.h"
 #include "components/html_viewer/web_media_player_factory.h"
+#include "components/resource_provider/public/cpp/resource_loader.h"
+#include "components/resource_provider/public/interfaces/resource_provider.mojom.h"
 #include "components/scheduler/renderer/renderer_scheduler.h"
 #include "gin/v8_initializer.h"
 #include "mojo/application/application_runner_chromium.h"
+#include "mojo/common/common_type_converters.h"
+#include "mojo/platform_handle/platform_handle_functions.h"
 #include "mojo/services/network/public/interfaces/network_service.mojom.h"
 #include "third_party/WebKit/public/web/WebKit.h"
 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
 #include "third_party/mojo/src/mojo/public/c/system/main.h"
 #include "third_party/mojo/src/mojo/public/cpp/application/application_connection.h"
 #include "third_party/mojo/src/mojo/public/cpp/application/application_delegate.h"
 #include "third_party/mojo/src/mojo/public/cpp/application/application_impl.h"
 #include "third_party/mojo/src/mojo/public/cpp/application/connect.h"
 #include "third_party/mojo/src/mojo/public/cpp/application/interface_factory_impl.h"
 #include "third_party/mojo/src/mojo/public/cpp/bindings/strong_binding.h"
@@ skipping 11 matching lines @@
 using mojo::Array;
 using mojo::BindToRequest;
 using mojo::ContentHandler;
 using mojo::InterfaceRequest;
 using mojo::ServiceProvider;
 using mojo::ServiceProviderPtr;
 using mojo::ShellPtr;
 using mojo::String;
 using mojo::URLLoaderPtr;
 using mojo::URLResponsePtr;
+using resource_provider::ResourceLoader;
 
 namespace html_viewer {
 
 // Switches for html_viewer.
 
 // Enable MediaRenderer in media pipeline instead of using the internal
 // media::Renderer implementation.
 const char kEnableMojoMediaRenderer[] = "enable-mojo-media-renderer";
 
 // Disables support for (unprefixed) Encrypted Media Extensions.
@@ skipping 101 matching lines @@
   bool is_headless_;
 
   DISALLOW_COPY_AND_ASSIGN(ContentHandlerImpl);
 };
 
 class HTMLViewer : public mojo::ApplicationDelegate,
                    public mojo::InterfaceFactory<ContentHandler> {
  public:
   HTMLViewer()
       : discardable_memory_allocator_(kDesiredMaxMemory),
-        compositor_thread_("compositor thread") {}
+        compositor_thread_("compositor thread"),
+        is_headless_(false) {}
 
   ~HTMLViewer() override { blink::shutdown(); }
 
  private:
   // Overridden from ApplicationDelegate:
   void Initialize(mojo::ApplicationImpl* app) override {
+    // TODO(sky): make this typesafe and not leak.
+    std::set<std::string> paths;
+    paths.insert("icudtl.dat");
+    paths.insert("ui_test.pak");
+#if defined(V8_USE_EXTERNAL_STARTUP_DATA)
+    paths.insert("natives_blob.bin");

[Jay Civelli, 2015/05/11 21:07:33]

Should we use constants for these strings since they appear more than once?

[sky, 2015/05/11 21:13:35]

Definitely. I'm hoping to do this later (see todo on 185).

+    paths.insert("snapshot_blob.bin");
+#endif
+    ResourceLoader resource_loader(app->shell(), paths);
+    if (!resource_loader.BlockUntilLoaded()) {
+      // Assume on error we're being shut down.
+      LOG(WARNING) << "html_viewer errored getting resources, exiting";
+      mojo::ApplicationImpl::Terminate();
+      return;
+    }
+
+    ResourceLoader::ResourceMap resource_map(resource_loader.resource_map());
+
     ui_setup_.reset(new UISetup);
     base::DiscardableMemoryAllocator::SetInstance(
         &discardable_memory_allocator_);
 
     renderer_scheduler_ = scheduler::RendererScheduler::Create();
     blink_platform_.reset(
         new BlinkPlatformImpl(app, renderer_scheduler_.get()));
 #if defined(V8_USE_EXTERNAL_STARTUP_DATA)
     // Note: this requires file system access.
-    gin::V8Initializer::LoadV8Snapshot();
+    CHECK(gin::V8Initializer::LoadV8SnapshotFromFD(
+        resource_map["natives_blob.bin"], 0u, 0u,
+        resource_map["snapshot_blob.bin"], 0u, 0u));
 #endif
     blink::initialize(blink_platform_.get());
-    base::i18n::InitializeICU();
+    base::i18n::InitializeICUWithFileDescriptor(
+        resource_map["icudtl.dat"], base::MemoryMappedFile::Region::kWholeFile);
 
     ui::RegisterPathProvider();
 
     base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 
     logging::LoggingSettings settings;
     settings.logging_dest = logging::LOG_TO_SYSTEM_DEBUG_LOG;
     logging::InitLogging(settings);
     // Display process ID, thread ID and timestamp in logs.
     logging::SetLogItems(true, true, true, false);
 
     if (command_line->HasSwitch(kDisableEncryptedMedia))
       blink::WebRuntimeFeatures::enableEncryptedMedia(false);
 
     is_headless_ = command_line->HasSwitch(kIsHeadless);
     if (!is_headless_) {
-      // TODO(sky): consider putting this into the .so so that we don't need
-      // file system access.
-      base::FilePath ui_test_pak_path;
-      CHECK(PathService::Get(ui::UI_TEST_PAK, &ui_test_pak_path));
-      ui::ResourceBundle::InitSharedInstanceWithPakPath(ui_test_pak_path);
+      // TODO(sky): fix lifetime here.
+      MojoPlatformHandle platform_handle = resource_map["ui_test.pak"];
+      // TODO(sky): the first call should be for strings, not images.
+      ui::ResourceBundle::InitSharedInstanceWithPakFileRegion(
+          base::File(platform_handle).Pass(),
+          base::MemoryMappedFile::Region::kWholeFile);
+      ui::ResourceBundle::GetSharedInstance().AddDataPackFromFile(
+          base::File(platform_handle).Pass(), ui::SCALE_FACTOR_100P);
     }
 
     compositor_thread_.Start();
 #if defined(OS_ANDROID)
     // TODO(sky): Get WebMediaPlayerFactory working on android.
     NOTIMPLEMENTED();
 #else
     bool enable_mojo_media_renderer =
         command_line->HasSwitch(kEnableMojoMediaRenderer);
 
@@ skipping 35 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(HTMLViewer);
 };
 
 }  // namespace html_viewer
 
 MojoResult MojoMain(MojoHandle shell_handle) {
   mojo::ApplicationRunnerChromium runner(new html_viewer::HTMLViewer);
   return runner.Run(shell_handle);
 }