Provide callback to create mojo AndroidOverlays to AVDA.

media/mojo/clients/mojo_android_overlay_unittest.cc

 // 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 <memory>
 
 #include "base/android/jni_android.h"
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 49 matching lines @@
       OverlayCreated();
     }
 
     MOCK_METHOD0(OverlayCreated, void(void));
 
     mojom::AndroidOverlayRequest overlay_request_;
     mojom::AndroidOverlayClientPtr client_;
     mojom::AndroidOverlayConfigPtr config_;
   };
 
-  // When the overlay client needs the provider interface, it'll ask us.
-  class MockInterfaceProvider
-      : public StrictMock<service_manager::mojom::InterfaceProvider> {
-   public:
-    // |provider| is the provider that we'll provide, provided that we're only
-    // asked to provide it once.  Savvy?
-    MockInterfaceProvider(mojom::AndroidOverlayProvider& provider)
-        : provider_binding_(&provider) {}
-
-    // We can't mock GetInterface directly because of |handle|'s deleted ctor.
-    MOCK_METHOD1(InterfaceGotten, void(const std::string&));
-
-    void GetInterface(const std::string& name,
-                      mojo::ScopedMessagePipeHandle handle) override {
-      // Let the mock know.
-      InterfaceGotten(name);
-
-      // Actually do the work.
-      provider_binding_.Bind(
-          mojom::AndroidOverlayProviderRequest(std::move(handle)));
-    }
-
-    mojo::Binding<mojom::AndroidOverlayProvider> provider_binding_;
-  };
-
  public:
   MojoAndroidOverlayTest()
-      : overlay_binding_(&mock_overlay_), interface_provider_(mock_provider_) {}
+      : provider_binding_(&mock_provider_), overlay_binding_(&mock_overlay_) {}
 
   ~MojoAndroidOverlayTest() override {}
 
   void SetUp() override {
     // Set up default config.
     config_.rect = gfx::Rect(100, 200, 300, 400);
     config_.ready_cb = base::Bind(&MockClientCallbacks::OnReady,
                                   base::Unretained(&callbacks_));
     config_.failed_cb = base::Bind(&MockClientCallbacks::OnFailed,
                                    base::Unretained(&callbacks_));
@@ skipping 13 matching lines @@
       // Drop the surface before the surface texture.
       surface_ = gl::ScopedJavaSurface();
     }
 
     base::RunLoop().RunUntilIdle();
   }
 
   // Create an overlay in |overlay_client_| using the current config, but do
   // not bind anything to |overlay_request_| yet.
   void CreateOverlay() {
-    EXPECT_CALL(interface_provider_,
-                InterfaceGotten(mojom::AndroidOverlayProvider::Name_))
-        .Times(1);
     EXPECT_CALL(mock_provider_, OverlayCreated());
 
     base::UnguessableToken routing_token = base::UnguessableToken::Create();
+    mojom::AndroidOverlayProviderPtr provider_ptr;
+    provider_binding_.Bind(mojo::MakeRequest(&provider_ptr));
+
     overlay_client_.reset(new MojoAndroidOverlay(
-        &interface_provider_, std::move(config_), routing_token));
+        std::move(provider_ptr), std::move(config_), routing_token));
     base::RunLoop().RunUntilIdle();
   }
 
   // Create an overlay, then provide it with |mock_overlay_|.
   void CreateAndInitializeOverlay() {
     CreateOverlay();
 
     // Bind an overlay to the request.
     overlay_binding_.Bind(std::move(mock_provider_.overlay_request_));
     base::RunLoop().RunUntilIdle();
@@ skipping 26 matching lines @@
     base::RunLoop().RunUntilIdle();
   }
 
   // Mojo stuff.
   base::MessageLoop loop;
 
   // The mock provider that |overlay_client_| will talk to.
   // |interface_provider_| will bind it.
   MockAndroidOverlayProvider mock_provider_;
 
+  // Binding for |mock_provider_|.
+  mojo::Binding<mojom::AndroidOverlayProvider> provider_binding_;
+
   // The mock overlay impl that |mock_provider_| will provide.
   MockAndroidOverlay mock_overlay_;
   mojo::Binding<mojom::AndroidOverlay> overlay_binding_;
 
-  // The InterfaceProvider impl that will provide |mock_provider_| to the
-  // overlay client |overlay_client_|.
-  MockInterfaceProvider interface_provider_;
-
   // The client under test.
   std::unique_ptr<AndroidOverlay> overlay_client_;
 
   // If we create a surface, then these are the SurfaceTexture that owns it,
   // the surface itself, and the key that we registered with GpuSurfaceLookup,
   // respectively.  We could probably mock out GpuSurfaceLookup, but we'd still
   // have to provide a (mock) ScopedJavaSurface, which isn't easy.
   scoped_refptr<gl::SurfaceTexture> surface_texture_;
   gl::ScopedJavaSurface surface_;
   int surface_key_ = 0;
@@ skipping 53 matching lines @@
 }
 
 // Test |secure| makes it to the mojo config when it is false
 TEST_F(MojoAndroidOverlayTest, SecureFlagIsSentViaMojoWhenFalse) {
   config_.secure = false;
   CreateOverlay();
   ASSERT_FALSE(mock_provider_.config_->secure);
 }
 
 }  // namespace media