Separate access token caching logic from signaling connector.

remoting/host/remoting_me2me_host.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.
 //
 // This file implements a standalone host process for Me2Me.
 
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
@@ skipping 256 matching lines @@
   std::string host_owner_;
   bool use_service_account_;
   scoped_ptr<policy_hack::PolicyWatcher> policy_watcher_;
   bool allow_nat_traversal_;
   std::string talkgadget_prefix_;
   bool allow_pairing_;
 
   bool curtain_required_;
   ThirdPartyAuthConfig third_party_auth_config_;
 
+  scoped_ptr<OAuthTokenGetter> oauth_token_getter_;
   scoped_ptr<XmppSignalStrategy> signal_strategy_;
   scoped_ptr<SignalingConnector> signaling_connector_;
   scoped_ptr<HeartbeatSender> heartbeat_sender_;
   scoped_ptr<HostStatusSender> host_status_sender_;
   scoped_ptr<HostChangeNotificationListener> host_change_notification_listener_;
   scoped_ptr<LogToServer> log_to_server_;
   scoped_ptr<HostEventLogger> host_event_logger_;
 
   scoped_ptr<ChromotingHost> host_;
 
@@ skipping 693 matching lines @@
 
   scoped_ptr<DnsBlackholeChecker> dns_blackhole_checker(
       new DnsBlackholeChecker(context_->url_request_context_getter(),
                               talkgadget_prefix_));
 
   // Create a NetworkChangeNotifier for use by the signaling connector.
   network_change_notifier_.reset(net::NetworkChangeNotifier::Create());
 
   signaling_connector_.reset(new SignalingConnector(
       signal_strategy_.get(),
-      context_->url_request_context_getter(),
       dns_blackhole_checker.Pass(),
       base::Bind(&HostProcess::OnAuthFailed, this)));
 
   if (!oauth_refresh_token_.empty()) {
-    scoped_ptr<SignalingConnector::OAuthCredentials> oauth_credentials(
-        new SignalingConnector::OAuthCredentials(
+    scoped_ptr<OAuthTokenGetter::OAuthCredentials> oauth_credentials;
+    oauth_credentials.reset(
+        new OAuthTokenGetter::OAuthCredentials(
             xmpp_server_config_.username, oauth_refresh_token_,
             use_service_account_));
-    signaling_connector_->EnableOAuth(oauth_credentials.Pass());
+
+    oauth_token_getter_.reset(new OAuthTokenGetter(
+        oauth_credentials.Pass(), context_->url_request_context_getter()));
+
+    signaling_connector_->EnableOAuth(oauth_token_getter_.get());
   }
 
   NetworkSettings network_settings(
       allow_nat_traversal_ ?
       NetworkSettings::NAT_TRAVERSAL_ENABLED :
       NetworkSettings::NAT_TRAVERSAL_DISABLED);
   if (!allow_nat_traversal_) {
     network_settings.min_port = NetworkSettings::kDefaultMinPort;
     network_settings.max_port = NetworkSettings::kDefaultMaxPort;
   }
@@ skipping 97 matching lines @@
 void HostProcess::ShutdownOnNetworkThread() {
   DCHECK(context_->network_task_runner()->BelongsToCurrentThread());
 
   host_.reset();
   host_event_logger_.reset();
   log_to_server_.reset();
   heartbeat_sender_.reset();
   host_status_sender_.reset();
   host_change_notification_listener_.reset();
   signaling_connector_.reset();
+  oauth_token_getter_.reset();
   signal_strategy_.reset();
   network_change_notifier_.reset();
 
   if (state_ == HOST_STOPPING_TO_RESTART) {
     StartHost();
   } else if (state_ == HOST_STOPPING) {
     state_ = HOST_STOPPED;
 
     if (policy_watcher_.get()) {
       base::WaitableEvent done_event(true, false);
@@ skipping 62 matching lines @@
   return exit_code;
 }
 
 }  // namespace remoting
 
 #if !defined(OS_WIN)
 int main(int argc, char** argv) {
   return remoting::HostMain(argc, argv);
 }
 #endif  // !defined(OS_WIN)