Bundle core applicatons in the shell.

shell/android/main.cc

 // Copyright 2013 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/android/main.h"
 
 #include <stdio.h>
 
 #include "base/android/fifo_utils.h"
 #include "base/android/jni_android.h"
@@ skipping 14 matching lines @@
 #include "base/threading/simple_thread.h"
 #include "gpu/config/gpu_util.h"
 #include "jni/ShellService_jni.h"
 #include "mojo/message_pump/message_pump_mojo.h"
 #include "mojo/services/network/public/interfaces/network_service.mojom.h"
 #include "mojo/services/window_manager/public/interfaces/window_manager.mojom.h"
 #include "shell/android/android_handler_loader.h"
 #include "shell/android/java_application_loader.h"
 #include "shell/android/native_viewport_application_loader.h"
 #include "shell/android/ui_application_loader_android.h"
+#include "shell/android/url_response_disk_cache_delegate_impl.h"
 #include "shell/application_manager/application_loader.h"
 #include "shell/background_application_loader.h"
 #include "shell/command_line_util.h"
 #include "shell/context.h"
 #include "shell/crash/breakpad.h"
 #include "shell/crash/crash_upload.h"
 #include "shell/init.h"
 #include "shell/switches.h"
 #include "shell/tracer.h"
 #include "ui/gl/gl_surface_egl.h"
@@ skipping 43 matching lines @@
   scoped_ptr<MojoShellRunner> shell_runner;
 
   // Thread to run the shell on.
   scoped_ptr<base::DelegateSimpleThread> shell_thread;
 
   // TaskRunner used to execute tasks on the shell thread.
   scoped_refptr<base::SingleThreadTaskRunner> shell_task_runner;
 
   // Event signalling when the shell task runner has been initialized.
   scoped_ptr<base::WaitableEvent> shell_runner_ready;
+
+  // Delegate for URLResponseDiskCache. Allows to access bundled application on
+  // cold start.
+  scoped_ptr<URLResponseDiskCacheDelegateImpl> url_response_disk_cache_delegate;
 };
 
 LazyInstance<InternalShellData> g_internal_data = LAZY_INSTANCE_INITIALIZER;
 
 void ConfigureAndroidServices(Context* context) {
   context->application_manager()->SetLoaderForURL(
       make_scoped_ptr(new UIApplicationLoader(
           make_scoped_ptr(new NativeViewportApplicationLoader()),
           g_internal_data.Get().java_message_loop.get())),
       GURL("mojo:native_viewport_service"));
@@ skipping 32 matching lines @@
 }
 
 void MojoShellRunner::Run() {
   base::MessageLoop loop(mojo::common::MessagePumpMojo::Create());
   g_internal_data.Get().shell_task_runner = loop.task_runner();
   // Signal that the shell is ready to receive requests.
   g_internal_data.Get().shell_runner_ready->Signal();
 
   Context* context = g_internal_data.Get().context.get();
   ConfigureAndroidServices(context);
-  CHECK(context->InitWithPaths(mojo_shell_child_path_));
+  CHECK(context->InitWithPaths(
+      mojo_shell_child_path_,
+      g_internal_data.Get().url_response_disk_cache_delegate.get()));
 
   RunCommandLineApps(context);
 
   loop.Run();
 
   g_internal_data.Get().java_message_loop.get()->PostTask(
       FROM_HERE, base::Bind(&QuitShellThread));
 }
 
 // Initialize stdout redirection if the command line switch is present.
@@ skipping 51 matching lines @@
                                                    &network_service);
   breakpad::UploadCrashes(dumps_path, context->task_runners()->blocking_pool(),
                           network_service.Pass());
 }
 
 }  // namespace
 
 static void Start(JNIEnv* env,
                   jclass clazz,
                   jobject application_context,
+                  jobject j_asset_manager,
                   jstring mojo_shell_child_path,
                   jobjectArray jparameters,
                   jstring j_local_apps_directory,
                   jstring j_tmp_dir,
                   jstring j_home_dir) {
   // Initially, the shell runner is not ready.
   g_internal_data.Get().shell_runner_ready.reset(
       new base::WaitableEvent(true, false));
 
   std::string tmp_dir = base::android::ConvertJavaStringToUTF8(env, j_tmp_dir);
@@ skipping 45 matching lines @@
   InitializeRedirection();
 
   // We want ~MessageLoop to happen prior to ~Context. Initializing
   // LazyInstances is akin to stack-allocating objects; their destructors
   // will be invoked first-in-last-out.
   Context* shell_context = new Context(tracer);
   shell_context->SetShellFileRoot(base::FilePath(
       base::android::ConvertJavaStringToUTF8(env, j_local_apps_directory)));
   g_internal_data.Get().context.reset(shell_context);
 
+  g_internal_data.Get().url_response_disk_cache_delegate.reset(
+      new URLResponseDiskCacheDelegateImpl(shell_context, j_asset_manager));
+
   g_internal_data.Get().java_message_loop.reset(new base::MessageLoopForUI);
   base::MessageLoopForUI::current()->Start();
   tracer->DidCreateMessageLoop();
 
   g_internal_data.Get().shell_thread.reset(new base::DelegateSimpleThread(
       g_internal_data.Get().shell_runner.get(), "ShellThread"));
   g_internal_data.Get().shell_thread->Start();
 
   // TODO(abarth): At which point should we switch to cross-platform
   // initialization?
@@ skipping 34 matching lines @@
                      mojo::MessagePipeHandle(services_handle))),
                  base::Passed(mojo::ScopedMessagePipeHandle(
                      mojo::MessagePipeHandle(exposed_services_handle)))));
 }
 
 bool RegisterShellService(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 }  // namespace shell