settings: Make DeviceOAuth2TokenServiceFactory::Get() async

chrome/browser/ui/webui/print_preview/print_preview_handler.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 "chrome/browser/ui/webui/print_preview/print_preview_handler.h"
 
 #include <ctype.h>
 
 #include <string>
 
@@ skipping 355 matching lines @@
   std::string printer_name;
   printing::ColorModel color_model;
   printing::ColorModel bw_model;
 };
 #endif
 
 class PrintPreviewHandler::AccessTokenService
     : public OAuth2TokenService::Consumer {
  public:
   explicit AccessTokenService(PrintPreviewHandler* handler)
-      : handler_(handler) {
+      : handler_(handler),
+        weak_factory_(this) {
   }
 
   void RequestToken(const std::string& type) {
     if (requests_.find(type) != requests_.end())
       return;  // Already in progress.
 
     OAuth2TokenService* service = NULL;
     std::string account_id;
     if (type == "profile") {
       Profile* profile = Profile::FromWebUI(handler_->web_ui());
       if (profile) {
         ProfileOAuth2TokenService* token_service =
             ProfileOAuth2TokenServiceFactory::GetForProfile(profile);
         account_id = token_service->GetPrimaryAccountId();
         service = token_service;
       }
     } else if (type == "device") {
 #if defined(OS_CHROMEOS)
-      chromeos::DeviceOAuth2TokenService* token_service =
-          chromeos::DeviceOAuth2TokenServiceFactory::Get();
-      account_id = token_service->GetRobotAccountId();
-      service = token_service;
+      chromeos::DeviceOAuth2TokenServiceFactory::Get(
+          base::Bind(
+              &AccessTokenService::DidGetTokenService,
+              weak_factory_.GetWeakPtr(),
+              type));
+      return;
 #endif
     }
 
+    ContinueRequestToken(type, service, account_id);
+  }
+
+#if defined(OS_CHROMEOS)
+  // Continuation of RequestToken().
+  void DidGetTokenService(const std::string& type,
+                          chromeos::DeviceOAuth2TokenService* token_service) {
+    std::string account_id;
+    if (token_service)
+      account_id = token_service->GetRobotAccountId();
+    ContinueRequestToken(type,
+                         token_service,
+                         account_id);
+  }
+#endif
+
+  // Continuation of RequestToken().
+  void ContinueRequestToken(const std::string& type,
+                            OAuth2TokenService* service,
+                            const std::string& account_id) {
     if (service) {
       OAuth2TokenService::ScopeSet oauth_scopes;
       oauth_scopes.insert(cloud_print::kCloudPrintAuth);
       scoped_ptr<OAuth2TokenService::Request> request(
           service->StartRequest(account_id, oauth_scopes, this));
       requests_[type].reset(request.release());
     } else {
       handler_->SendAccessToken(type, std::string());  // Unknown type.
     }
   }
@@ skipping 19 matching lines @@
         return;
       }
     }
     NOTREACHED();
   }
 
   typedef std::map<std::string,
                    linked_ptr<OAuth2TokenService::Request> > Requests;
   Requests requests_;
   PrintPreviewHandler* handler_;
+  base::WeakPtrFactory<AccessTokenService> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(AccessTokenService);
 };
 
 PrintPreviewHandler::PrintPreviewHandler()
     : print_backend_(printing::PrintBackend::CreateInstance(NULL)),
       regenerate_preview_request_count_(0),
       manage_printers_dialog_request_count_(0),
       manage_cloud_printers_dialog_request_count_(0),
       reported_failed_preview_(false),
@@ skipping 784 matching lines @@
     settings->SetInteger(printing::kSettingColor, bw_model);
     return;
   }
   DCHECK_EQ(printing::COLOR, color);
   printing::ColorModel color_model = cups_printer_color_models_->color_model;
   if (color_model != printing::UNKNOWN_COLOR_MODEL)
     settings->SetInteger(printing::kSettingColor, color_model);
 }
 
 #endif