Deprecate CredentialRequestOptions.unmediated in favor mediation enum

third_party/WebKit/Source/modules/credentialmanager/CredentialsContainer.cpp

 // 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 "modules/credentialmanager/CredentialsContainer.h"
 
 #include <memory>
 #include <utility>
 #include "bindings/core/v8/Dictionary.h"
 #include "bindings/core/v8/ScriptPromise.h"
@@ skipping 10 matching lines @@
 #include "modules/credentialmanager/CredentialRequestOptions.h"
 #include "modules/credentialmanager/FederatedCredential.h"
 #include "modules/credentialmanager/FederatedCredentialRequestOptions.h"
 #include "modules/credentialmanager/PasswordCredential.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "platform/wtf/PtrUtil.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCredential.h"
 #include "public/platform/WebCredentialManagerClient.h"
 #include "public/platform/WebCredentialManagerError.h"
+#include "public/platform/WebCredentialMediationRequirement.h"
 #include "public/platform/WebFederatedCredential.h"
 #include "public/platform/WebPasswordCredential.h"
 
 namespace blink {
 
 static void RejectDueToCredentialManagerError(
     ScriptPromiseResolver* resolver,
     WebCredentialManagerError reason) {
   switch (reason) {
     case kWebCredentialManagerDisabledError:
@@ skipping 120 matching lines @@
 }
 
 ScriptPromise CredentialsContainer::get(
     ScriptState* script_state,
     const CredentialRequestOptions& options) {
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
   if (!CheckBoilerplate(resolver))
     return promise;
 
+  // Set the default mediation option if none is provided.

[vasilii, 2017/05/18 16:16:12]

I think it does more. Copying one to another.

[jdoerrie, 2017/05/19 09:03:18]

Done.

+  if (!options.hasUnmediated() && !options.hasMediation()) {
+    options.mediation() = "optional";
+  } else if (options.hasUnmediated() && !options.hasMediation()) {
+    options.mediation() = options.unmediated() ? "silent" : "optional";
+  } else if (options.hasUnmediated() && options.hasMediation()) {
+    resolver->Reject(DOMException::Create(
+        kNotSupportedError,
+        "At most one of 'unmediated' and 'mediation' can be specified."));
+    return promise;
+  }
+
   Vector<KURL> providers;
   if (options.hasFederated() && options.federated().hasProviders()) {
     for (const auto& string : options.federated().providers()) {
       KURL url = KURL(KURL(), string);
       if (url.IsValid())
         providers.push_back(std::move(url));
     }
   }
 
-  UseCounter::Count(ExecutionContext::From(script_state),
-                    options.unmediated()
-                        ? UseCounter::kCredentialManagerGetWithoutUI
-                        : UseCounter::kCredentialManagerGetWithUI);
+  UseCounter::Feature feature;
+  WebCredentialMediationRequirement mediation;
+
+  if (options.mediation() == "silent") {
+    feature = UseCounter::kCredentialManagerGetMediationSilent;
+    mediation = WebCredentialMediationRequirement::kSilent;
+  } else if (options.mediation() == "optional") {
+    feature = UseCounter::kCredentialManagerGetMediationOptional;
+    mediation = WebCredentialMediationRequirement::kOptional;
+  } else {
+    DCHECK_EQ("required", options.mediation());
+    feature = UseCounter::kCredentialManagerGetMediationRequired;
+    mediation = WebCredentialMediationRequirement::kRequired;
+  }
+
+  UseCounter::Count(ExecutionContext::From(script_state), feature);
 
   CredentialManagerClient::From(ExecutionContext::From(script_state))
-      ->DispatchGet(options.unmediated(), options.password(), providers,
+      ->DispatchGet(mediation, options.password(), providers,
                     new RequestCallbacks(resolver));
   return promise;
 }
 
 ScriptPromise CredentialsContainer::store(ScriptState* script_state,
                                           Credential* credential) {
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
   if (!CheckBoilerplate(resolver))
     return promise;
@@ skipping 11 matching lines @@
   ScriptPromise promise = resolver->Promise();
   if (!CheckBoilerplate(resolver))
     return promise;
 
   CredentialManagerClient::From(ExecutionContext::From(script_state))
       ->DispatchRequireUserMediation(new NotificationCallbacks(resolver));
   return promise;
 }
 
 }  // namespace blink