Allow dynamic updating of authentication policies

net/http/http_auth_handler_negotiate_unittest.cc

 // Copyright (c) 2012 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/http/mock_allow_http_auth_preferences.h>

[asanka, 2015/11/25 19:00:10]

#include "..."

[aberent, 2015/11/26 15:58:00]

Done.

 #include "net/http/http_auth_handler_negotiate.h"
 
 #include <string>
 
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/http/http_request_info.h"
-#include "net/http/mock_allow_url_security_manager.h"
 #if defined(OS_ANDROID)
 #include "net/android/dummy_spnego_authenticator.h"
 #elif defined(OS_WIN)
 #include "net/http/mock_sspi_library_win.h"
 #elif defined(OS_POSIX)
 #include "net/http/mock_gssapi_library_posix.h"
 #endif
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 namespace net {
 
 #if defined(OS_ANDROID)
 typedef net::android::DummySpnegoAuthenticator MockAuthLibrary;
 #elif defined(OS_WIN)
 typedef MockSSPILibrary MockAuthLibrary;
 #elif defined(OS_POSIX)
 typedef test::MockGSSAPILibrary MockAuthLibrary;
 #endif
 
 class HttpAuthHandlerNegotiateTest : public PlatformTest {
  public:
   void SetUp() override {
     auth_library_ = new MockAuthLibrary();
     resolver_.reset(new MockHostResolver());
     resolver_->rules()->AddIPLiteralRule("alias", "10.0.0.2",
                                            "canonical.example.com");
 
-    url_security_manager_.reset(new MockAllowURLSecurityManager());
+    http_auth_preferences_.reset(new MockAllowHttpAuthPreferences());
     factory_.reset(new HttpAuthHandlerNegotiate::Factory());
-    factory_->set_url_security_manager(url_security_manager_.get());
+    factory_->set_http_auth_preferences(http_auth_preferences_.get());
 #if defined(OS_ANDROID)
-    std::string* authenticator =
-        new std::string("org.chromium.test.DummySpnegoAuthenticator");
-    factory_->set_library(authenticator);
+    http_auth_preferences_->set_auth_android_negotiate_account_type(
+        "org.chromium.test.DummySpnegoAuthenticator");
     MockAuthLibrary::EnsureTestAccountExists();
 #endif
 #if defined(OS_WIN) || (defined(OS_POSIX) && !defined(OS_ANDROID))
-    factory_->set_library(auth_library_);
+    factory_->set_library(make_scoped_ptr(auth_library_));
 #endif
     factory_->set_host_resolver(resolver_.get());
   }
 
 #if defined(OS_ANDROID)
   void TearDown() override { MockAuthLibrary::RemoveTestAccounts(); }
 #endif
 
   void SetupMocks(MockAuthLibrary* mock_library) {
 #if defined(OS_WIN)
@@ skipping 122 matching lines @@
                                         query.expected_input_token,
                                         query.output_token);
   }
 
 #endif  // defined(OS_POSIX)
 
   int CreateHandler(bool disable_cname_lookup, bool use_port,
                      bool synchronous_resolve_mode,
                      const std::string& url_string,
                      scoped_ptr<HttpAuthHandlerNegotiate>* handler) {
-    factory_->set_disable_cname_lookup(disable_cname_lookup);
-    factory_->set_use_port(use_port);
+    http_auth_preferences_->set_negotiate_disable_cname_lookup(
+        disable_cname_lookup);
+    http_auth_preferences_->set_negotiate_enable_port(use_port);
     resolver_->set_synchronous_mode(synchronous_resolve_mode);
     GURL gurl(url_string);
 
     // Note: This is a little tricky because CreateAuthHandlerFromString
     // expects a scoped_ptr<HttpAuthHandler>* rather than a
     // scoped_ptr<HttpAuthHandlerNegotiate>*. This needs to do the cast
     // after creating the handler, and make sure that generic_handler
     // no longer holds on to the HttpAuthHandlerNegotiate object.
     scoped_ptr<HttpAuthHandler> generic_handler;
     int rv = factory_->CreateAuthHandlerFromString("Negotiate",
                                                    HttpAuth::AUTH_SERVER,
                                                    gurl,
                                                    BoundNetLog(),
                                                    &generic_handler);
     if (rv != OK)
       return rv;
     HttpAuthHandlerNegotiate* negotiate_handler =
         static_cast<HttpAuthHandlerNegotiate*>(generic_handler.release());
     handler->reset(negotiate_handler);
     return rv;
   }
 
   MockAuthLibrary* AuthLibrary() { return auth_library_; }
 
  private:
 #if defined(OS_WIN)
   scoped_ptr<SecPkgInfoW> security_package_;
 #endif
-  // |auth_library_| is passed to |factory_|, which assumes ownership of it.
+  // |auth_library_| is passed to |factory_|, which assumes ownership of it, but
+  // can't be a scoped pointer to it since the tests need access when they set
+  // up the mocks after passing ownership.
   MockAuthLibrary* auth_library_;
   scoped_ptr<MockHostResolver> resolver_;
-  scoped_ptr<URLSecurityManager> url_security_manager_;
+  scoped_ptr<MockAllowHttpAuthPreferences> http_auth_preferences_;
   scoped_ptr<HttpAuthHandlerNegotiate::Factory> factory_;
 };
 
 TEST_F(HttpAuthHandlerNegotiateTest, DisableCname) {
   SetupMocks(AuthLibrary());
   scoped_ptr<HttpAuthHandlerNegotiate> auth_handler;
   EXPECT_EQ(OK, CreateHandler(
       true, false, true, "http://alias:500", &auth_handler));
 
   ASSERT_TRUE(auth_handler.get() != NULL);
@@ skipping 112 matching lines @@
   HttpRequestInfo request_info;
   std::string token;
   EXPECT_EQ(ERR_IO_PENDING, auth_handler->GenerateAuthToken(
       NULL, &request_info, callback.callback(), &token));
   EXPECT_EQ(ERR_MISSING_AUTH_CREDENTIALS, callback.WaitForResult());
 }
 
 #if defined(DLOPEN_KERBEROS)
 TEST_F(HttpAuthHandlerNegotiateTest, MissingGSSAPI) {
   scoped_ptr<HostResolver> host_resolver(new MockHostResolver());
-  MockAllowURLSecurityManager url_security_manager;
+  MockAllowHttpAuthPreferences http_auth_preferences;
   scoped_ptr<HttpAuthHandlerNegotiate::Factory> negotiate_factory(
       new HttpAuthHandlerNegotiate::Factory());
-  negotiate_factory->set_host_resolver(host_resolver.get());
-  negotiate_factory->set_url_security_manager(&url_security_manager);
+  negotiate_factory->set_host_resolver(host_resolver);
+  negotiate_factory->set_http_auth_preferences(&http_auth_preferences);
   negotiate_factory->set_library(
-      new GSSAPISharedLibrary("/this/library/does/not/exist"));
+      make_scoped_ptr(new GSSAPISharedLibrary("/this/library/does/not/exist")));
 
   GURL gurl("http://www.example.com");
   scoped_ptr<HttpAuthHandler> generic_handler;
   int rv = negotiate_factory->CreateAuthHandlerFromString(
       "Negotiate",
       HttpAuth::AUTH_SERVER,
       gurl,
       BoundNetLog(),
       &generic_handler);
   EXPECT_EQ(ERR_UNSUPPORTED_AUTH_SCHEME, rv);
   EXPECT_TRUE(generic_handler.get() == NULL);
 }
 #endif  // defined(DLOPEN_KERBEROS)
 
 #endif  // defined(OS_POSIX)
 
 }  // namespace net