Allow dynamic updating of authentication policies

net/android/http_auth_negotiate_android.cc

 // Copyright 2015 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 "net/android/http_auth_negotiate_android.h"
 
 #include "base/android/jni_string.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/location.h"
 #include "base/thread_task_runner_handle.h"
 #include "jni/HttpNegotiateAuthenticator_jni.h"
 #include "net/base/auth.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_auth_challenge_tokenizer.h"
 #include "net/http/http_auth_multi_round_parse.h"
+#include "net/http/http_auth_preferences.h"
 
 using base::android::AttachCurrentThread;
 using base::android::ConvertUTF8ToJavaString;
 using base::android::ConvertJavaStringToUTF8;
 using base::android::ScopedJavaLocalRef;
 
 namespace net {
 namespace android {
 
 JavaNegotiateResultWrapper::JavaNegotiateResultWrapper(
@@ skipping 19 matching lines @@
   // the original thread in an obscure error case.
   callback_task_runner_->PostTask(
       FROM_HERE, base::Bind(thread_safe_callback_, result, raw_token));
   // We will always get precisely one call to set result for each call to
   // getNextAuthToken, so we can now delete the callback object, and must
   // do so to avoid a memory leak.
   delete this;
 }
 
 HttpAuthNegotiateAndroid::HttpAuthNegotiateAndroid(
-    const std::string& account_type)
-    : account_type_(account_type),
+    const HttpAuthPreferences* prefs)
+    : prefs_(prefs),
       can_delegate_(false),
       first_challenge_(true),
       auth_token_(nullptr),
       weak_factory_(this) {
-  DCHECK(!account_type.empty());
   JNIEnv* env = AttachCurrentThread();
   java_authenticator_.Reset(Java_HttpNegotiateAuthenticator_create(
-      env, ConvertUTF8ToJavaString(env, account_type).obj()));
+      env,
+      ConvertUTF8ToJavaString(env, prefs->AuthAndroidNegotiateAccountType())
+          .obj()));
 }
 
 HttpAuthNegotiateAndroid::~HttpAuthNegotiateAndroid() {
 }
 
 bool HttpAuthNegotiateAndroid::Register(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
 bool HttpAuthNegotiateAndroid::Init() {
@@ skipping 17 matching lines @@
   std::string decoded_auth_token;
   return net::ParseLaterRoundChallenge("negotiate", tok, &server_auth_token_,
                                        &decoded_auth_token);
 }
 
 int HttpAuthNegotiateAndroid::GenerateAuthToken(
     const AuthCredentials* credentials,
     const std::string& spn,
     std::string* auth_token,
     const net::CompletionCallback& callback) {
+  if (prefs_->AuthAndroidNegotiateAccountType().empty()) {
+    // This can happen if there is a policy change, removing the account type,
+    // in the middle of a negotiation.
+    return ERR_UNSUPPORTED_AUTH_SCHEME;
+  }
   DCHECK(auth_token);
   DCHECK(completion_callback_.is_null());
   DCHECK(!callback.is_null());
 
   auth_token_ = auth_token;
   completion_callback_ = callback;
   scoped_refptr<base::SingleThreadTaskRunner> callback_task_runner =
       base::ThreadTaskRunnerHandle::Get();
   base::Callback<void(int, const std::string&)> thread_safe_callback =
       base::Bind(&HttpAuthNegotiateAndroid::SetResultInternal,
                  weak_factory_.GetWeakPtr());
   JNIEnv* env = AttachCurrentThread();
   ScopedJavaLocalRef<jstring> java_server_auth_token =
       ConvertUTF8ToJavaString(env, server_auth_token_);
   ScopedJavaLocalRef<jstring> java_spn = ConvertUTF8ToJavaString(env, spn);
   ScopedJavaLocalRef<jstring> java_account_type =
-      ConvertUTF8ToJavaString(env, account_type_);
+      ConvertUTF8ToJavaString(env, prefs_->AuthAndroidNegotiateAccountType());
 
   // It is intentional that callback_wrapper is not owned or deleted by the
   // HttpAuthNegotiateAndroid object. The Java code will call the callback
   // asynchronously on a different thread, and needs an object to call it on. As
   // such, the callback_wrapper must not be deleted until the callback has been
   // called, whatever happens to the HttpAuthNegotiateAndroid object.
   //
   // Unfortunately we have no automated way of managing C++ objects owned by
   // Java, so the Java code must simply be written to guarantee that the
   // callback is, in the end, called.
@@ skipping 14 matching lines @@
                                                  const std::string& raw_token) {
   DCHECK(auth_token_);
   DCHECK(!completion_callback_.is_null());
   if (result == OK)
     *auth_token_ = "Negotiate " + raw_token;
   base::ResetAndReturn(&completion_callback_).Run(result);
 }
 
 }  // namespace android
 }  // namespace net