Mojo framework for AndroidOverlay.

content/browser/gpu/gpu_process_host.cc

 // Copyright (c) 2012 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/browser/gpu/gpu_process_host.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 57 matching lines @@
 #include "services/service_manager/public/cpp/connection.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
 #include "services/service_manager/runner/common/client_util.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/events/latency_info.h"
 #include "ui/gfx/switches.h"
 #include "ui/gl/gl_switches.h"
 
 #if defined(OS_ANDROID)
 #include "base/android/build_info.h"
+#include "content/public/browser/android/java_interfaces.h"
+#include "media/mojo/interfaces/android_overlay.mojom.h"
+#include "services/service_manager/public/cpp/interface_registry.h"
 #endif
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #include "content/common/sandbox_win.h"
 #include "sandbox/win/src/sandbox_policy.h"
 #include "ui/gfx/switches.h"
 #include "ui/gfx/win/rendering_window_manager.h"
 #endif
 
@@ skipping 223 matching lines @@
 void HostLoadedShader(int host_id,
                       const std::string& key,
                       const std::string& data) {
   GpuProcessHost* host = GpuProcessHost::FromID(host_id);
   if (host)
     host->LoadedShader(key, data);
 }
 
 }  // anonymous namespace
 
+#if defined(OS_ANDROID)
+template <typename Interface>
+void BindJavaInterface(mojo::InterfaceRequest<Interface> request) {

[boliu, 2017/02/17 21:20:51]

if we end up creating a separate registry for gpu, then this could move to that
code

if not, I think gpu_process_host_ui_shim might be better, since that's like the
"UI" part of GpuProcessHost

[liberato (no reviews please), 2017/02/22 16:25:01]

moved to UI shim, per offline discussion.

+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+  content::GetGlobalJavaInterfaces()->GetInterface(std::move(request));
+}
+
+// Binder which posts each request to the UI thread.
+template <typename Interface>
+void BindJavaInterfaceOnUIThread(mojo::InterfaceRequest<Interface> request) {
+  BrowserThread::GetTaskRunnerForThread(BrowserThread::UI)
+      ->PostTask(FROM_HERE, base::Bind(&BindJavaInterface<Interface>,
+                                       base::Passed(&request)));
+}
+#endif
+
 class GpuProcessHost::ConnectionFilterImpl : public ConnectionFilter {
  public:
   ConnectionFilterImpl(GpuProcessHost* host) : host_(host) {}
 
  private:
   // ConnectionFilter:
   bool OnConnect(const service_manager::Identity& remote_identity,
                  service_manager::InterfaceRegistry* registry,
                  service_manager::Connector* connector) override {
     if (remote_identity.name() != mojom::kGpuServiceName)
       return false;
 
     GetContentClient()->browser()->ExposeInterfacesToGpuProcess(registry,
                                                                 host_);
+
+#if defined(OS_ANDROID)
+    registry->AddInterface(base::Bind(
+        &BindJavaInterfaceOnUIThread<media::mojom::AndroidOverlayProvider>));
+#endif
+
     return true;
   }
 
   GpuProcessHost* host_;
 
   DISALLOW_COPY_AND_ASSIGN(ConnectionFilterImpl);
 };
 
 // static
 bool GpuProcessHost::ValidateHost(GpuProcessHost* host) {
@@ skipping 840 matching lines @@
       GetShaderCacheFactorySingleton()->Get(client_id);
   if (!cache.get())
     return;
 
   cache->set_shader_loaded_callback(base::Bind(&HostLoadedShader, host_id_));
 
   client_id_to_shader_cache_[client_id] = cache;
 }
 
 }  // namespace content