Enable loading gssapi library for Chromad.

net/http/http_auth_handler_factory.cc

 // Copyright (c) 2010 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_factory.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "net/base/net_errors.h"
@@ skipping 70 matching lines @@
     registry_factory->RegisterSchemeFactory(kNtlmAuthScheme, ntlm_factory);
   }
 #if defined(USE_KERBEROS)
   if (prefs.IsSupportedScheme(kNegotiateAuthScheme)) {
     DCHECK(host_resolver);
     HttpAuthHandlerNegotiate::Factory* negotiate_factory =
         new HttpAuthHandlerNegotiate::Factory();
 #if defined(OS_WIN)
     negotiate_factory->set_library(base::MakeUnique<SSPILibraryDefault>());
 #elif defined(OS_POSIX) && !defined(OS_ANDROID)
-    negotiate_factory->set_library(
-        base::MakeUnique<GSSAPISharedLibrary>(prefs.GssapiLibraryName()));
+    bool allow_gssapi_library_load = true;
+#if defined(OS_CHROMEOS)
+    allow_gssapi_library_load = prefs.AllowGssapiLibraryLoad();
+#endif
+    negotiate_factory->set_library(base::MakeUnique<GSSAPISharedLibrary>(
+        prefs.GssapiLibraryName(), allow_gssapi_library_load));

[asanka, 2017/04/26 20:42:25]

Rather than this, let's make HttpAuthHandlerNegotiate::Factory fail if there's
no library. That way we can skip creating the library entirely on ChromeOS if
allow_gssapi_library_load is false.

It's seems unnecessary to construct a library that just returns
ERR_UNSUPPORTED_AUTH_SCHEME all the time.

 #endif  // defined(OS_POSIX) && !defined(OS_ANDROID)
     negotiate_factory->set_host_resolver(host_resolver);
     registry_factory->RegisterSchemeFactory(kNegotiateAuthScheme,
                                             negotiate_factory);
   }
 #endif  // defined(USE_KERBEROS)
   return registry_factory;
 }
 
 }  // namespace
@@ skipping 36 matching lines @@
 // static
 std::unique_ptr<HttpAuthHandlerRegistryFactory>
 HttpAuthHandlerFactory::CreateDefault(HostResolver* host_resolver) {
   std::vector<std::string> auth_types(std::begin(kDefaultAuthSchemes),
                                       std::end(kDefaultAuthSchemes));
   HttpAuthPreferences prefs(auth_types
 #if defined(OS_POSIX) && !defined(OS_ANDROID)
                             ,
                             std::string()
 #endif
-                                );
+#if defined(OS_CHROMEOS)
+                                ,
+                            true
+#endif
+                            );
   return CreateAuthHandlerRegistryFactory(prefs, host_resolver);
 }
 
 // static
 std::unique_ptr<HttpAuthHandlerRegistryFactory>
 HttpAuthHandlerRegistryFactory::Create(const HttpAuthPreferences* prefs,
                                        HostResolver* host_resolver) {
   std::unique_ptr<HttpAuthHandlerRegistryFactory> registry_factory(
       CreateAuthHandlerRegistryFactory(*prefs, host_resolver));
   registry_factory->set_http_auth_preferences(prefs);
@@ skipping 23 matching lines @@
     handler->reset();
     return ERR_UNSUPPORTED_AUTH_SCHEME;
   }
   DCHECK(it->second);
   return it->second->CreateAuthHandler(challenge, target, ssl_info, origin,
                                        reason, digest_nonce_count, net_log,
                                        handler);
 }
 
 }  // namespace net