Deprecate CredentialRequestOptions.unmediated in favor mediation enum

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 "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
 #include "content/public/test/render_view_test.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "services/service_manager/public/cpp/interface_provider.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/";
 
@@ skipping 10 matching lines @@
   // mojom::CredentialManager methods:
   void Store(const CredentialInfo& credential,
              StoreCallback callback) override {
     std::move(callback).Run();
   }
 
   void RequireUserMediation(RequireUserMediationCallback callback) override {
     std::move(callback).Run();
   }
 
-  void Get(bool zero_click_only,
+  void Get(CredentialMediationRequirement mediation,
            bool include_passwords,
            const std::vector<GURL>& federations,
            GetCallback callback) override {
     const std::string& url = federations[0].spec();
 
     if (url == kTestCredentialPassword) {
       CredentialInfo info;
       info.type = CredentialType::CREDENTIAL_TYPE_PASSWORD;
       std::move(callback).Run(mojom::CredentialManagerError::SUCCESS, info);
     } else if (url == kTestCredentialEmpty) {
@@ skipping 133 matching lines @@
 
   EXPECT_TRUE(callback_succeeded());
   EXPECT_FALSE(callback_errored());
 }
 
 TEST_F(CredentialManagerClientTest, SendRequestCredential) {
   std::unique_ptr<TestRequestCallbacks> callbacks(
       new TestRequestCallbacks(this));
   std::vector<GURL> federations;
   federations.push_back(GURL(kTestCredentialPassword));
-  client_->DispatchGet(false, true, federations, callbacks.release());
+  client_->DispatchGet(blink::WebCredentialMediationRequirement::kOptional,
+                       true, federations, callbacks.release());
 
   RunAllPendingTasks();
 
   EXPECT_TRUE(callback_succeeded());
   EXPECT_FALSE(callback_errored());
   EXPECT_TRUE(credential_);
   EXPECT_EQ("password", credential_->GetType());
 }
 
 TEST_F(CredentialManagerClientTest, SendRequestCredentialEmpty) {
   std::unique_ptr<TestRequestCallbacks> callbacks(
       new TestRequestCallbacks(this));
   std::vector<GURL> federations;
   federations.push_back(GURL(kTestCredentialEmpty));
-  client_->DispatchGet(false, true, federations, callbacks.release());
+  client_->DispatchGet(blink::WebCredentialMediationRequirement::kOptional,
+                       true, federations, callbacks.release());
 
   RunAllPendingTasks();
 
   EXPECT_TRUE(callback_succeeded());
   EXPECT_FALSE(callback_errored());
   EXPECT_FALSE(credential_);
 }
 
 TEST_F(CredentialManagerClientTest, SendRequestCredentialReject) {
   std::unique_ptr<TestRequestCallbacks> callbacks(
       new TestRequestCallbacks(this));
   std::vector<GURL> federations;
   federations.push_back(GURL(kTestCredentialReject));
-  client_->DispatchGet(false, true, federations, callbacks.release());
+  client_->DispatchGet(blink::WebCredentialMediationRequirement::kOptional,
+                       true, federations, callbacks.release());
 
   RunAllPendingTasks();
 
   EXPECT_FALSE(callback_succeeded());
   EXPECT_TRUE(callback_errored());
   EXPECT_FALSE(credential_);
   EXPECT_EQ(blink::WebCredentialManagerError::
                 kWebCredentialManagerPasswordStoreUnavailableError,
             error_);
 }
 
 }  // namespace password_manager