Makes ResourceLoader own handles and return Files

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"
@@ skipping 37 matching lines @@
 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 {
-
+namespace {
 // 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.
 const char kDisableEncryptedMedia[] = "disable-encrypted-media";
 
 // Prevents creation of any output surface.
 const char kIsHeadless[] = "is-headless";
 
 size_t kDesiredMaxMemory = 20 * 1024 * 1024;
 
+// Paths resources are loaded from.
+const char kResourceIcudtl[] = "icudtl.dat";
+const char kResourceResourcesPak[] = "html_viewer_resources.pak";
+const char kResourceUIPak[] = "ui_test.pak";
+#if defined(V8_USE_EXTERNAL_STARTUP_DATA)
+const char kResourceNativesBlob[] = "natives_blob.bin";
+const char kResourceSnapshotBlob[] = "snapshot_blob.bin";
+#endif
+
+}  // namespace
+
 class HTMLViewer;
 
 class HTMLViewerApplication : public mojo::Application {
  public:
   HTMLViewerApplication(InterfaceRequest<Application> request,
                         URLResponsePtr response,
                         scoped_refptr<base::MessageLoopProxy> compositor_thread,
                         WebMediaPlayerFactory* web_media_player_factory,
                         bool is_headless)
       : url_(response->url),
@@ skipping 92 matching lines @@
   HTMLViewer()
       : discardable_memory_allocator_(kDesiredMaxMemory),
         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");
+    paths.insert(kResourceResourcesPak);
+    paths.insert(kResourceIcudtl);
+    paths.insert(kResourceUIPak);
 #if defined(V8_USE_EXTERNAL_STARTUP_DATA)
-    paths.insert("natives_blob.bin");
-    paths.insert("snapshot_blob.bin");
+    paths.insert(kResourceNativesBlob);
+    paths.insert(kResourceSnapshotBlob);
 #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.
     CHECK(gin::V8Initializer::LoadV8SnapshotFromFD(
-        resource_map["natives_blob.bin"], 0u, 0u,
-        resource_map["snapshot_blob.bin"], 0u, 0u));
+        resource_loader.ReleaseFile(kResourceNativesBlob).TakePlatformFile(),
+        0u, 0u,
+        resource_loader.ReleaseFile(kResourceSnapshotBlob).TakePlatformFile(),
+        0u, 0u));
 #endif
     blink::initialize(blink_platform_.get());
     base::i18n::InitializeICUWithFileDescriptor(
-        resource_map["icudtl.dat"], base::MemoryMappedFile::Region::kWholeFile);
+        resource_loader.ReleaseFile(kResourceIcudtl).TakePlatformFile(),
+        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): 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(),
+          resource_loader.ReleaseFile(kResourceResourcesPak),
           base::MemoryMappedFile::Region::kWholeFile);
       ui::ResourceBundle::GetSharedInstance().AddDataPackFromFile(
-          base::File(platform_handle).Pass(), ui::SCALE_FACTOR_100P);
+          resource_loader.ReleaseFile(kResourceUIPak), 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);
 }