Use shared shared URLRequestContextGetter for all gcd_private sessions

chrome/browser/extensions/api/gcd_private/privet_v3_session.cc

 // Copyright 2014 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 "chrome/browser/extensions/api/gcd_private/privet_v3_session.h"
 
 #include "base/base64.h"
 #include "base/json/json_writer.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
+#include "chrome/browser/extensions/api/gcd_private/privet_v3_context_getter.h"
 #include "chrome/browser/local_discovery/privet_constants.h"
 #include "chrome/browser/local_discovery/privet_http.h"
 #include "chrome/browser/local_discovery/privet_http_impl.h"
 #include "chrome/browser/local_discovery/privet_url_fetcher.h"
 #include "chrome/common/cloud_print/cloud_print_constants.h"
 #include "crypto/hmac.h"
 #include "crypto/p224_spake.h"
 #include "url/gurl.h"
 
 using local_discovery::PrivetURLFetcher;
@@ skipping 179 matching lines @@
   url_fetcher_.reset();
 }
 
 void PrivetV3Session::FetcherDelegate::OnTimeout() {
   LOG(ERROR) << "PrivetURLFetcher timeout, url: " << url_fetcher_->url();
   ReplyAndDestroyItself(Result::STATUS_CONNECTIONERROR,
                         base::DictionaryValue());
 }
 
 PrivetV3Session::PrivetV3Session(
-    const scoped_refptr<net::URLRequestContextGetter>& context_getter,
+    const scoped_refptr<PrivetV3ContextGetter>& context_getter,
     const net::HostPortPair& host_port)
     : client_(new local_discovery::PrivetHTTPClientImpl("",
                                                         host_port,
                                                         context_getter)),
-      weak_ptr_factory_(this) {}
+      context_getter_(context_getter),
+      weak_ptr_factory_(this) {
+  CHECK(context_getter_);
+}
 
 PrivetV3Session::~PrivetV3Session() {
   Cancel();
 }
 
 void PrivetV3Session::Init(const InitCallback& callback) {
   DCHECK(fetchers_.empty());
   DCHECK(!client_->IsInHttpsMode());
   DCHECK(session_id_.empty());
   DCHECK(privet_auth_token_.empty());
@@ skipping 132 matching lines @@
   }
 
   std::string auth_code(hmac.DigestLength(), ' ');
   if (!hmac.Sign(session_id_,
                  reinterpret_cast<unsigned char*>(string_as_array(&auth_code)),
                  auth_code.size())) {
     LOG(FATAL) << "Signing failed";
     return callback.Run(Result::STATUS_SESSIONERROR);
   }
 
-  // From now use only https with fixed certificate.
   VLOG(1) << "Expected certificate: " << fingerprint;
-  client_->SwitchToHttps(https_port_, hash);
+  context_getter_->AddPairedHost(
+      client_->GetHost(), hash,
+      base::Bind(&PrivetV3Session::OnPairedHostAddedToContext,
+                 weak_ptr_factory_.GetWeakPtr(), auth_code, callback));
+}
+
+void PrivetV3Session::OnPairedHostAddedToContext(
+    const std::string& auth_code,
+    const ResultCallback& callback) {
+  // Now use https with fixed certificate.
+  client_->SwitchToHttps(https_port_);
 
   std::string auth_code_base64;
   base::Base64Encode(auth_code, &auth_code_base64);
 
   base::DictionaryValue input;
   input.SetString(kPrivetV3KeyAuthCode, auth_code_base64);
   input.SetString(kPrivetV3KeyMode, kPrivetV3KeyPairing);
   input.SetString(kPrivetV3KeyRequestedScope, kPrivetV3Auto);
 
   // Now we can use SendMessage with certificate validation.
@@ skipping 79 matching lines @@
 void PrivetV3Session::Cancel() {
   // Cancel started unconfirmed sessions.
   if (session_id_.empty() || client_->IsInHttpsMode())
     return;
   base::DictionaryValue input;
   input.SetString(kPrivetV3KeySessionId, session_id_);
   StartPostRequest(kPrivetV3PairingCancelPath, input, MessageCallback());
 }
 
 }  // namespace extensions