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 InterfaceType>
+void AddUIInterfaceHelper(service_manager::InterfaceRegistry* registry) {

[boliu, 2017/02/16 22:24:19]

Hmm, I don't know mojo at all.. my immediate question here is what's the
lifetime and thread safety guarantees of registry here.

Plus this class is all on the IO thread, can this be done somewhere else? Maybe
GpuProcessHostUIShim?

[liberato (no reviews please), 2017/02/17 17:47:12]

(fixed per rockot@'s suggestions.)

+  registry->AddInterface(
+      content::GetGlobalJavaInterfaces()
+          ->CreateInterfaceFactory<InterfaceType>(),
+      BrowserThread::GetTaskRunnerForThread(BrowserThread::UI));
+}
+
+template <typename InterfaceType>
+void AddUIInterface(service_manager::InterfaceRegistry* registry) {
+  BrowserThread::GetTaskRunnerForThread(BrowserThread::UI)
+      ->PostTask(FROM_HERE,
+                 base::Bind(&AddUIInterfaceHelper<InterfaceType>, registry));

[Ken Rockot(use gerrit already), 2017/02/17 06:29:56]

This is not safe, and CreateInterfaceFactory() while convenient is unfortunately
not sufficient for this case. |registry| lives on the IO thread where the
ConnectionFilter lives, so you can't just post to the UI thread to register a
binder on it there. Instead, you want to register a binder on the IO thread
which itself posts to the UI thread to handle each individual request, like so:

template <typename Interface>
void BindJavaInterface(mojo::InterfaceRequest<Interface> request) {
  DCHECK(/* on the UI thread */);
  content::GetGlobalJavaInterfaces()->GetInterface(std::move(request));
}

template <typename Interface>
void BindJavaInterfaceOnUIThread(mojo::InterfaceRequest<Interface> request) {
  BrowserThread::GetTaskRunnerForThread(BrowserThread::UI)->PostTask(
      FROM_HERE, base::Bind(&BindJavaInterface<Interface>,
base::Passed(&request));
}

/// ... in OnConnect

registry->AddInterface(base::Bind(
    &BindJavaInterfaceOnUIThread<media::mojom::AndroidOverlayProvider>));

[liberato (no reviews please), 2017/02/17 17:47:12]

thank you very much!

+}
+#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)
+    AddUIInterface<media::mojom::AndroidOverlayProvider>(registry);
+#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