Mus experiment in content shell on Android.

content/shell/browser/shell_content_browser_client.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 "content/shell/browser/shell_content_browser_client.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/base_switches.h"
@@ skipping 30 matching lines @@
 #include "net/url_request/url_request_context_getter.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "url/gurl.h"
 #include "url/origin.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/apk_assets.h"
 #include "base/android/path_utils.h"
 #include "components/crash/content/browser/crash_dump_manager_android.h"
 #include "content/shell/android/shell_descriptors.h"
+#include "services/ui/demo/mus_demo.h"  // nogncheck
+#include "services/ui/ime/test_ime_driver/test_ime_application.h"  // nogncheck
+#include "services/ui/service.h"  // nogncheck
 #endif
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 #include "base/debug/leak_annotations.h"
 #include "components/crash/content/app/breakpad_linux.h"
 #include "components/crash/content/browser/crash_handler_host_linux.h"
 #include "content/public/common/content_descriptors.h"
 #endif
 
 #if defined(OS_WIN)
@@ skipping 53 matching lines @@
     static breakpad::CrashHandlerHostLinux* crash_handler = NULL;
     if (!crash_handler)
       crash_handler = CreateCrashHandlerHost(process_type);
     return crash_handler->GetDeathSignalSocket();
   }
 
   return -1;
 }
 #endif  // defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
 
+#if defined(OS_ANDROID)
+
+// Factory methods to create embedded services.
+
+std::unique_ptr<service_manager::Service> CreateMojoUIApplication(
+    const base::Closure& quit_closure) {
+  return std::unique_ptr<service_manager::Service>(new ui::Service());
+}
+
+std::unique_ptr<service_manager::Service> CreateMojoTestIMEApplication(
+    const base::Closure& quit_closure) {
+  return std::unique_ptr<service_manager::Service>(
+      new ui::test::TestIMEApplication());
+}
+
+std::unique_ptr<service_manager::Service> CreateMojoMusDemoService(
+    const base::Closure& quit_closure) {
+  return std::unique_ptr<ui::demo::MusDemo>(new ui::demo::MusDemo());
+}
+
+#endif  // defined(OS_ANDROID)
+
 }  // namespace
 
 ShellContentBrowserClient* ShellContentBrowserClient::Get() {
   return g_browser_client;
 }
 
 void ShellContentBrowserClient::SetSwapProcessesForRedirect(bool swap) {
   g_swap_processes_for_redirect = swap;
 }
 
@@ skipping 53 matching lines @@
   return false;
 }
 
 void ShellContentBrowserClient::RegisterInProcessServices(
     StaticServiceMap* services) {
 #if (ENABLE_MOJO_MEDIA_IN_BROWSER_PROCESS)
   content::ServiceInfo info;
   info.factory = base::Bind(&media::CreateMediaServiceForTesting);
   services->insert(std::make_pair("service:media", info));
 #endif
+#if defined(OS_ANDROID)
+  // Register Mus and the required services for the Mus demo to run.
+  content::ServiceInfo mus_info;
+  mus_info.factory = base::Bind(&CreateMojoUIApplication);
+  mus_info.service_owns_context = true;
+  services->insert(std::make_pair("service:ui", mus_info));
+
+  content::ServiceInfo mus_demo_info;
+  mus_demo_info.factory = base::Bind(&CreateMojoMusDemoService);
+  mus_demo_info.service_owns_context = true;
+  services->insert(std::make_pair("service:mus_demo", mus_demo_info));
+
+  content::ServiceInfo test_ime_info;
+  test_ime_info.factory = base::Bind(&CreateMojoTestIMEApplication);
+  test_ime_info.service_owns_context = true;
+  services->insert(std::make_pair("service:test_ime_driver", test_ime_info));
+#endif
 }
 
 void ShellContentBrowserClient::RegisterOutOfProcessServices(
       OutOfProcessServiceMap* services) {
   services->insert(std::make_pair(kTestServiceUrl,
                                   base::UTF8ToUTF16("Test Service")));
 }
 
 std::unique_ptr<base::Value>
 ShellContentBrowserClient::GetServiceManifestOverlay(
@@ skipping 165 matching lines @@
 ShellBrowserContext* ShellContentBrowserClient::browser_context() {
   return shell_browser_main_parts_->browser_context();
 }
 
 ShellBrowserContext*
     ShellContentBrowserClient::off_the_record_browser_context() {
   return shell_browser_main_parts_->off_the_record_browser_context();
 }
 
 }  // namespace content