Restrict CM API interface request and message dispatch.

components/password_manager/content/renderer/credential_manager_client_browsertest.cc

 // Copyright 2014 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 "components/password_manager/content/renderer/credential_manager_client.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <tuple>
 #include <utility>
 
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
+#include "content/public/common/associated_interface_provider.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/test/render_view_test.h"
 #include "content/public/test/test_utils.h"
-#include "mojo/public/cpp/bindings/binding_set.h"
-#include "services/service_manager/public/cpp/interface_provider.h"
+#include "mojo/public/cpp/bindings/associated_binding_set.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebCredential.h"
 #include "third_party/WebKit/public/platform/WebCredentialManagerClient.h"
 #include "third_party/WebKit/public/platform/WebCredentialManagerError.h"
 #include "third_party/WebKit/public/platform/WebCredentialMediationRequirement.h"
 #include "third_party/WebKit/public/platform/WebPasswordCredential.h"
 
 namespace password_manager {
 
 namespace {
 
 const char kTestCredentialPassword[] = "https://password.com/";
 const char kTestCredentialEmpty[] = "https://empty.com/";
 const char kTestCredentialReject[] = "https://reject.com/";
 
 class FakeCredentialManager : public mojom::CredentialManager {
  public:
   FakeCredentialManager() {}
   ~FakeCredentialManager() override {}
 
-  void BindRequest(mojom::CredentialManagerRequest request) {
+  void BindRequest(mojom::CredentialManagerAssociatedRequest request) {
     bindings_.AddBinding(this, std::move(request));
   }
 
  private:
   // mojom::CredentialManager methods:
   void Store(const CredentialInfo& credential,
              StoreCallback callback) override {
     std::move(callback).Run();
   }
 
@@ skipping 14 matching lines @@
     } else if (url == kTestCredentialEmpty) {
       std::move(callback).Run(mojom::CredentialManagerError::SUCCESS,
                               CredentialInfo());
     } else if (url == kTestCredentialReject) {
       std::move(callback).Run(
           mojom::CredentialManagerError::PASSWORDSTOREUNAVAILABLE,
           base::nullopt);
     }
   }
 
-  mojo::BindingSet<mojom::CredentialManager> bindings_;
+  mojo::AssociatedBindingSet<mojom::CredentialManager> bindings_;
 };
 
 class CredentialManagerClientTest : public content::RenderViewTest {
  public:
   CredentialManagerClientTest()
       : callback_errored_(false), callback_succeeded_(false) {}
   ~CredentialManagerClientTest() override {}
 
   void SetUp() override {
     content::RenderViewTest::SetUp();
     client_.reset(new CredentialManagerClient(view_));
 
-    service_manager::InterfaceProvider* remote_interfaces =
-        view_->GetMainRenderFrame()->GetRemoteInterfaces();
-    service_manager::InterfaceProvider::TestApi test_api(remote_interfaces);
-    test_api.SetBinderForName(
+    content::AssociatedInterfaceProvider* remote_interfaces =
+        view_->GetMainRenderFrame()->GetRemoteAssociatedInterfaces();
+    remote_interfaces->OverrideBinderForTesting(
         mojom::CredentialManager::Name_,
         base::Bind(&CredentialManagerClientTest::BindCredentialManager,
                    base::Unretained(this)));
   }
 
   void TearDown() override {
     credential_.reset();
     client_.reset();
     content::RenderViewTest::TearDown();
   }
 
   bool callback_errored() const { return callback_errored_; }
   void set_callback_errored(bool state) { callback_errored_ = state; }
   bool callback_succeeded() const { return callback_succeeded_; }
   void set_callback_succeeded(bool state) { callback_succeeded_ = state; }
 
-  void BindCredentialManager(mojo::ScopedMessagePipeHandle handle) {
-    fake_cm_.BindRequest(mojom::CredentialManagerRequest(std::move(handle)));
+  void BindCredentialManager(mojo::ScopedInterfaceEndpointHandle handle) {
+    fake_cm_.BindRequest(
+        mojom::CredentialManagerAssociatedRequest(std::move(handle)));
   }
 
   std::unique_ptr<blink::WebPasswordCredential> credential_;
   blink::WebCredentialManagerError error_;
 
  protected:
   std::unique_ptr<CredentialManagerClient> client_;
 
   FakeCredentialManager fake_cm_;
 
@@ skipping 121 matching lines @@
 
   EXPECT_FALSE(callback_succeeded());
   EXPECT_TRUE(callback_errored());
   EXPECT_FALSE(credential_);
   EXPECT_EQ(blink::WebCredentialManagerError::
                 kWebCredentialManagerPasswordStoreUnavailableError,
             error_);
 }
 
 }  // namespace password_manager