Native api to get OAuth2 access tokens in Print Preview Web UI.

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 17 matching lines @@
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_url.h"
 #include "chrome/browser/printing/print_dialog_cloud.h"
 #include "chrome/browser/printing/print_error_dialog.h"
 #include "chrome/browser/printing/print_job_manager.h"
 #include "chrome/browser/printing/print_preview_dialog_controller.h"
 #include "chrome/browser/printing/print_system_task_proxy.h"
 #include "chrome/browser/printing/print_view_manager.h"
 #include "chrome/browser/printing/printer_manager_dialog.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/signin/oauth2_token_service.h"
+#include "chrome/browser/signin/oauth2_token_service_factory.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/chrome_select_file_policy.h"
 #include "chrome/browser/ui/webui/print_preview/print_preview_ui.h"
 #include "chrome/browser/ui/webui/print_preview/sticky_settings.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/print_messages.h"
 #include "content/public/browser/browser_context.h"
@@ skipping 21 matching lines @@
 using content::BrowserThread;
 using content::NavigationEntry;
 using content::OpenURLParams;
 using content::RenderViewHost;
 using content::Referrer;
 using content::WebContents;
 using printing::Metafile;
 
 namespace {
 
+// The cloud print OAuth2 scope.
+const char kCloudPrintAuth[] = "https://www.googleapis.com/auth/cloudprint";
+
 enum UserActionBuckets {
   PRINT_TO_PRINTER,
   PRINT_TO_PDF,
   CANCEL,
   FALLBACK_TO_ADVANCED_SETTINGS_DIALOG,
   PREVIEW_FAILED,
   PREVIEW_STARTED,
   INITIATOR_TAB_CRASHED,  // UNUSED
   INITIATOR_TAB_CLOSED,
   PRINT_WITH_CLOUD_PRINT,
@@ skipping 140 matching lines @@
       BrowserThread::UI, FROM_HERE,
       base::Bind(&base::DeletePointer<Metafile>, metafile));
 }
 #endif
 
 static base::LazyInstance<printing::StickySettings> sticky_settings =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
+class PrintPreviewHandler::AccessTokenService
+    : public OAuth2TokenService::Consumer {
+ public:
+  typedef const base::Callback<void(const std::string&,
+                                    const std::string&)> CompleteonCallback;
+
+  explicit AccessTokenService(const CompleteonCallback& callback)
+      : callback_(callback) {
+  }
+
+  void AddOAuth2TokenService(const std::string& type,
+                             OAuth2TokenService* service) {
+    services_.push_back(make_linked_ptr(new Service()));
+    services_.back()->type = type;
+    services_.back()->service = service;
+  }
+
+  void RequestToken(const std::string& type) {
+    for (Services::iterator i = services_.begin();
+         i != services_.end(); ++i) {
+      Service& service = **i;
+      if (service.type == type) {
+        if (service.request)  // Already in progress.
+          return;
+        OAuth2TokenService::ScopeSet oauth_scopes;
+        oauth_scopes.insert(kCloudPrintAuth);
+        service.request = service.service->StartRequest(oauth_scopes, this);
+        return;
+      }
+    }
+    callback_.Run(type, std::string());  // Unknown type.
+  }
+
+  void OnGetTokenSuccess(const OAuth2TokenService::Request* request,
+                         const std::string& access_token,
+                         const base::Time& expiration_time) OVERRIDE {
+    OnServiceResponce(request, access_token);
+  }
+
+  void OnGetTokenFailure(const OAuth2TokenService::Request* request,
+                         const GoogleServiceAuthError& error) OVERRIDE {
+    OnServiceResponce(request, std::string());
+  }
+
+ private:
+  void OnServiceResponce(const OAuth2TokenService::Request* request,
+                         const std::string& access_token) {
+    for (Services::iterator i = services_.begin();
+         i != services_.end(); ++i) {
+      Service& service = **i;
+      if (service.request == request) {
+        service.request.reset();
+        callback_.Run(service.type, access_token);
+        return;
+      }
+    }
+    NOTREACHED();
+  }
+
+  struct Service {
+    std::string type;
+    OAuth2TokenService* service;
+    scoped_ptr<OAuth2TokenService::Request> request;
+  };
+  typedef std::vector<linked_ptr<Service> > Services;
+  Services services_;
+  CompleteonCallback callback_;
+
+  DISALLOW_COPY_AND_ASSIGN(AccessTokenService);
+};
+
 // static
 printing::StickySettings* PrintPreviewHandler::GetStickySettings() {
   return sticky_settings.Pointer();
 }
 
 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),
@@ skipping 19 matching lines @@
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("getPrinterCapabilities",
       base::Bind(&PrintPreviewHandler::HandleGetPrinterCapabilities,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("showSystemDialog",
       base::Bind(&PrintPreviewHandler::HandleShowSystemDialog,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("signIn",
       base::Bind(&PrintPreviewHandler::HandleSignin,
                  base::Unretained(this)));
+  web_ui()->RegisterMessageCallback("getAccessToken",
+      base::Bind(&PrintPreviewHandler::HandleGetAccessToken,
+                 base::Unretained(this)));
   web_ui()->RegisterMessageCallback("manageCloudPrinters",
       base::Bind(&PrintPreviewHandler::HandleManageCloudPrint,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("manageLocalPrinters",
       base::Bind(&PrintPreviewHandler::HandleManagePrinters,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("closePrintPreviewDialog",
       base::Bind(&PrintPreviewHandler::HandleClosePreviewDialog,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("hidePreview",
@@ skipping 290 matching lines @@
 
 void PrintPreviewHandler::HandleSignin(const ListValue* /*args*/) {
   gfx::NativeWindow modal_parent = platform_util::GetTopLevel(
       preview_web_contents()->GetView()->GetNativeView());
   print_dialog_cloud::CreateCloudPrintSigninDialog(
       preview_web_contents()->GetBrowserContext(),
       modal_parent,
       base::Bind(&PrintPreviewHandler::OnSigninComplete, AsWeakPtr()));
 }
 
+void PrintPreviewHandler::HandleGetAccessToken(const base::ListValue* args) {
+  std::string type;
+  if (!args->GetString(0, &type))
+    return;
+  if (!token_service_)
+    InitTokenService();
+  token_service_->RequestToken(type);
+}
+
+void PrintPreviewHandler::InitTokenService() {
+  token_service_.reset(
+      new AccessTokenService(base::Bind(&PrintPreviewHandler::SendAccessToken,
+                                        base::Unretained(this))));
+  Profile* profile = Profile::FromWebUI(web_ui());
+  OAuth2TokenService* profile_service =
+      OAuth2TokenServiceFactory::GetForProfile(profile);
+  if (profile_service) {
+    token_service_->AddOAuth2TokenService("profile", profile_service);
+    // TODO(vitalybuka): Replace with source of device tokens.
+    token_service_->AddOAuth2TokenService("device", profile_service);
+  }
+}
+
 void PrintPreviewHandler::PrintWithCloudPrintDialog(
     const base::RefCountedBytes* data,
     const string16& title) {
   // Record the number of times the user asks to print via cloud print
   // instead of the print preview dialog.
   ReportStats();
 
   gfx::NativeWindow modal_parent = platform_util::GetTopLevel(
       preview_web_contents()->GetView()->GetNativeView());
   print_dialog_cloud::CreatePrintDialogForBytes(
@@ skipping 178 matching lines @@
     GetNumberFormatAndMeasurementSystem(&initial_settings);
   web_ui()->CallJavascriptFunction("setInitialSettings", initial_settings);
 }
 
 void PrintPreviewHandler::ClosePreviewDialog() {
   PrintPreviewUI* print_preview_ui =
       static_cast<PrintPreviewUI*>(web_ui()->GetController());
   print_preview_ui->OnClosePrintPreviewDialog();
 }
 
+void PrintPreviewHandler::SendAccessToken(const std::string& type,
+                                          const std::string& access_token) {
+  VLOG(1) << "Get getAccessToken finished";
+  web_ui()->CallJavascriptFunction("onDidGetAccessToken", StringValue(type),
+                                   StringValue(access_token));
+}
+
 void PrintPreviewHandler::SendPrinterCapabilities(
     const DictionaryValue& settings_info) {
   VLOG(1) << "Get printer capabilities finished";
   web_ui()->CallJavascriptFunction("updateWithPrinterCapabilities",
                                    settings_info);
 }
 
 void PrintPreviewHandler::SendFailedToGetPrinterCapabilities(
     const std::string& printer_name) {
   VLOG(1) << "Get printer capabilities failed";
@@ skipping 168 matching lines @@
     // Nothing to print, no preview available.
     return false;
   }
   DCHECK(tmp_data->size() && tmp_data->front());
 
   *data = tmp_data;
   *title = print_preview_ui->initiator_tab_title();
   return true;
 }