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/http_auth_handler_negotiate.h"
 
 #include <string>
 
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 27 matching lines @@
   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());
     factory_.reset(new HttpAuthHandlerNegotiate::Factory());
     factory_->set_url_security_manager(url_security_manager_.get());
 #if defined(OS_ANDROID)
-    std::string* authenticator =
-        new std::string("org.chromium.test.DummySpnegoAuthenticator");
-    factory_->set_library(authenticator);
+    scoped_ptr<std::string> authenticator(
+        new std::string("org.chromium.test.DummySpnegoAuthenticator"));
+    factory_->set_library(authenticator.Pass());
     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_));

[asanka, 2015/10/28 03:27:43]

Preexisting: This is dangerous territory. Can we avoid passing ownership while
keeping a reference?

[aberent, 2015/11/02 18:52:50]

Not without significant refactoring of the tests (probably taking this out of
setup and doing it in the individual tests). This isn't new, the factory
internally always took ownership; it simply didn't declare in its interface that
it was going to (i.e. it took a straight pointer that it then used internally to
update a scoped pointer, see the old comment at line 227). As such I think
fixing this should be a different CL.

 #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 152 matching lines @@
     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<HttpAuthHandlerNegotiate::Factory> factory_;
 };
 
 TEST_F(HttpAuthHandlerNegotiateTest, DisableCname) {
   SetupMocks(AuthLibrary());
   scoped_ptr<HttpAuthHandlerNegotiate> auth_handler;
   EXPECT_EQ(OK, CreateHandler(
@@ skipping 121 matching lines @@
 
 #if defined(DLOPEN_KERBEROS)
 TEST_F(HttpAuthHandlerNegotiateTest, MissingGSSAPI) {
   scoped_ptr<HostResolver> host_resolver(new MockHostResolver());
   MockAllowURLSecurityManager url_security_manager;
   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_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