Allow dynamic updating of authentication policies

google_apis/gcm/tools/mcs_probe.cc

 // Copyright 2013 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.
 //
 // A standalone tool for testing MCS connections and the MCS client on their
 // own.
 
 #include <cstddef>
 #include <cstdio>
 #include <string>
@@ skipping 20 matching lines @@
 #include "google_apis/gcm/engine/checkin_request.h"
 #include "google_apis/gcm/engine/connection_factory_impl.h"
 #include "google_apis/gcm/engine/gcm_store_impl.h"
 #include "google_apis/gcm/engine/gservices_settings.h"
 #include "google_apis/gcm/engine/mcs_client.h"
 #include "google_apis/gcm/monitoring/fake_gcm_stats_recorder.h"
 #include "net/base/host_mapping_rules.h"
 #include "net/cert/cert_verifier.h"
 #include "net/dns/host_resolver.h"
 #include "net/http/http_auth_handler_factory.h"
+#include "net/http/http_auth_preferences.h"
+#include "net/http/http_auth_scheme.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_server_properties_impl.h"
 #include "net/http/transport_security_state.h"
 #include "net/log/write_to_file_net_log_observer.h"
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/default_channel_id_store.h"
 #include "net/url_request/url_request_test_util.h"
 
@@ skipping 125 matching lines @@
              int flags,
              net::CRLSet* crl_set,
              net::CertVerifyResult* verify_result,
              const net::CompletionCallback& callback,
              scoped_ptr<Request>* out_req,
              const net::BoundNetLog& net_log) override {
     return net::OK;
   }
 };
 
+class MCSProbeAuthPreferences : public net::HttpAuthPreferences {
+  std::vector<std::string> auth_schemes() const override {
+    return std::vector<std::string>(1, net::kBasicAuthScheme);
+  }
+  bool negotiate_disable_cname_lookup() const override { return false; }
+  bool negotiate_enable_port() const override { return false; }
+  bool CanUseDefaultCredentials(const GURL& auth_origin) const override {
+    return false;
+  }
+  bool CanDelegate(const GURL& auth_origin) const override { return false; }
+};
+
 class MCSProbe {
  public:
   MCSProbe(
       const base::CommandLine& command_line,
       scoped_refptr<net::URLRequestContextGetter> url_request_context_getter);
   ~MCSProbe();
 
   void Start();
 
   uint64 android_id() const { return android_id_; }
@@ skipping 22 matching lines @@
   int server_port_;
 
   // Network state.
   scoped_refptr<net::URLRequestContextGetter> url_request_context_getter_;
   net::NetLog net_log_;
   scoped_ptr<net::WriteToFileNetLogObserver> logger_;
   scoped_ptr<net::HostResolver> host_resolver_;
   scoped_ptr<net::CertVerifier> cert_verifier_;
   scoped_ptr<net::ChannelIDService> system_channel_id_service_;
   scoped_ptr<net::TransportSecurityState> transport_security_state_;
-  scoped_ptr<net::URLSecurityManager> url_security_manager_;
+  MCSProbeAuthPreferences http_auth_preferences;
   scoped_ptr<net::HttpAuthHandlerFactory> http_auth_handler_factory_;
   scoped_ptr<net::HttpServerPropertiesImpl> http_server_properties_;
   scoped_ptr<net::HostMappingRules> host_mapping_rules_;
   scoped_ptr<net::HttpNetworkSession> network_session_;
   scoped_ptr<net::ProxyService> proxy_service_;
 
   FakeGCMStatsRecorder recorder_;
   scoped_ptr<GCMStore> gcm_store_;
   scoped_ptr<MCSClient> mcs_client_;
   scoped_ptr<CheckinRequest> checkin_request_;
@@ skipping 130 matching lines @@
     cert_verifier_.reset(new MyTestCertVerifier());
   } else {
     cert_verifier_ = net::CertVerifier::CreateDefault();
   }
   system_channel_id_service_.reset(
       new net::ChannelIDService(
           new net::DefaultChannelIDStore(NULL),
           base::WorkerPool::GetTaskRunner(true)));
 
   transport_security_state_.reset(new net::TransportSecurityState());
-  url_security_manager_.reset(net::URLSecurityManager::Create(NULL, NULL));
-  http_auth_handler_factory_.reset(net::HttpAuthHandlerRegistryFactory::Create(
-      std::vector<std::string>(1, "basic"), url_security_manager_.get(),
-      host_resolver_.get(), std::string(), std::string(), false, false));
+  http_auth_handler_factory_ = net::HttpAuthHandlerRegistryFactory::Create(
+                                   &http_auth_preferences, host_resolver_.get())
+                                   .Pass();
   http_server_properties_.reset(new net::HttpServerPropertiesImpl());
   host_mapping_rules_.reset(new net::HostMappingRules());
   proxy_service_ = net::ProxyService::CreateDirectWithNetLog(&net_log_);
 }
 
 void MCSProbe::BuildNetworkSession() {
   net::HttpNetworkSession::Params session_params;
   session_params.host_resolver = host_resolver_.get();
   session_params.cert_verifier = cert_verifier_.get();
   session_params.channel_id_service = system_channel_id_service_.get();
@@ skipping 97 matching lines @@
 
   return 0;
 }
 
 }  // namespace
 }  // namespace gcm
 
 int main(int argc, char* argv[]) {
   return gcm::MCSProbeMain(argc, argv);
 }