Mojo framework for AndroidOverlay.

media/mojo/clients/mojo_android_overlay.cc

Index: media/mojo/clients/mojo_android_overlay.cc
diff --git a/media/mojo/clients/mojo_android_overlay.cc b/media/mojo/clients/mojo_android_overlay.cc
new file mode 100644
index 0000000000000000000000000000000000000000..2bacaf323671a4d6ba66f982583955032a15e1a1
--- /dev/null
+++ b/media/mojo/clients/mojo_android_overlay.cc
@@ -0,0 +1,122 @@
+// Copyright 2017 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 "media/mojo/clients/mojo_android_overlay.h"
+
+#include "mojo/public/cpp/bindings/associated_binding.h"
+#include "mojo/public/cpp/bindings/binding.h"
+#include "services/service_manager/public/cpp/connect.h"
+#include "services/service_manager/public/interfaces/interface_provider.mojom.h"
+
+namespace media {
+
+// Callback that we send to the provider impl.  It just notifies the overlay.
+// Will be deleted before the MojoAndroidOverlay that owns it is.
+class MojoAndroidOverlayClient : public mojom::AndroidOverlayClient {
+ public:
+  MojoAndroidOverlayClient(mojom::AndroidOverlayClientRequest request,
+                           MojoAndroidOverlay* overlay)
+      : overlay_(overlay), binding_(this, std::move(request)) {}
+
+  void OnInitialized(mojom::AndroidOverlayPtr ptr) override {
+    overlay_->OnInitialized(std::move(ptr));
+  }
+
+  void OnSurfaceReady(uint64_t surface_key) override {
+    overlay_->OnSurfaceReady(surface_key);
+  }
+
+  void OnDestroyed() override { overlay_->OnDestroyed(); }
+
+ private:
+  MojoAndroidOverlay* overlay_;
+  mojo::Binding<mojom::AndroidOverlayClient> binding_;
+
+  DISALLOW_COPY_AND_ASSIGN(MojoAndroidOverlayClient);
+};
+
+MojoAndroidOverlay::MojoAndroidOverlay(
+    service_manager::mojom::InterfaceProvider* interface_provider,
+    int render_frame_id,
+    int renderer_pid,
+    const AndroidOverlay::Config& config)
+    : interface_provider_(interface_provider) {
+  // Connect to the provider service.
+  mojom::AndroidOverlayProviderPtr provider_ptr;
+  service_manager::GetInterface<mojom::AndroidOverlayProvider>(
+      interface_provider_, &provider_ptr);
+
+  Setup(std::move(provider_ptr), render_frame_id, renderer_pid, config);
+}
+
+MojoAndroidOverlay::MojoAndroidOverlay(
+    mojom::AndroidOverlayProviderPtr provider_ptr,
+    int render_frame_id,
+    int renderer_pid,
+    const AndroidOverlay::Config& config) {
+  Setup(std::move(provider_ptr), render_frame_id, renderer_pid, config);
+}
+
+MojoAndroidOverlay::~MojoAndroidOverlay() {
+  // Dropping |overlay_ptr_| will signal to the implementation that we're done
+  // with the surface.  If a synchronous destroy is pending, then it can be
+  // allowed to continue.
+
+  // We don't want any callbacks once destruction starts.
+  client_ = nullptr;
+}
+
+void MojoAndroidOverlay::Setup(mojom::AndroidOverlayProviderPtr provider_ptr,
+                               int render_frame_id,
+                               int renderer_pid,
+                               const AndroidOverlay::Config& config) {
+  config_ = config;
+  provider_ptr_ = std::move(provider_ptr);
+
+  // Create the overlay client that will notify us.
+  mojom::AndroidOverlayClientPtr ptr;
+  client_ = base::MakeUnique<MojoAndroidOverlayClient>(MakeRequest(&ptr), this);
+
+  // Construct the config.  While our caller could provide this, we also want to
+  // get (and retain) |config_|.
+  mojom::AndroidOverlayConfigPtr mojo_config =
+      mojom::AndroidOverlayConfig::New();
+  mojo_config->render_frame_id = render_frame_id;
+  mojo_config->renderer_pid = renderer_pid;
+  mojo_config->rect = config_.rect;
+  provider_ptr_->CreateOverlay(std::move(ptr), std::move(mojo_config));
+}
+
+void MojoAndroidOverlay::ScheduleLayout(const gfx::Rect& rect) {
+  // If we haven't gotten the overlay yet, then ignore this.
+  if (!overlay_ptr_.is_bound())
+    return;
+
+  if (!received_surface_)
+    return;
+
+  overlay_ptr_->ScheduleLayout(rect);
+}
+
+void MojoAndroidOverlay::OnInitialized(mojom::AndroidOverlayPtr ptr) {
+  overlay_ptr_ = std::move(ptr);
+}
+
+void MojoAndroidOverlay::OnSurfaceReady(uint32_t surface_key) {
+  // TODO(liberato): ask binder for the surface.

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

Side note in case this is interesting: we're actively looking into enabling
wrapping of Parcelable  objects as generic Mojo handles so they can be
transmitted seamlessly over message pipes. No ETA yet, but there should be more
developments soon.

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

that is very exciting news!

is there a design doc?  i'm interested in how that will work.

i can think of only two ways: (a) do something magic with parceled file
descriptors, or (b) use binder under the hood.

+  gl::ScopedJavaSurface surface;
+  received_surface_ = true;
+  config_.ready_cb.Run(std::move(surface));
+}
+
+void MojoAndroidOverlay::OnDestroyed() {
+  // Note that |overlay_ptr_| might not be bound yet, or we might not have ever
+  // gotten a surface.  Regardless, the overlay cannot be used.
+  config_.destroyed_cb.Run();
+
+  // Note: we do not delete |overlay_ptr_| here.  Our client must delete us to
+  // signal that we should do that, since it still might be in use.
+}
+
+}  // namespace media