Modify experimental identity flow to display scope descriptions and details.

chrome/browser/extensions/extension_install_prompt.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/extensions/extension_install_prompt.h"
 
 #include <map>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/bundle_installer.h"
 #include "chrome/browser/extensions/extension_install_dialog.h"
 #include "chrome/browser/extensions/extension_install_ui.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/signin/token_service.h"
+#include "chrome/browser/signin/token_service_factory.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_icon_set.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/extensions/extension_switch_utils.h"
 #include "chrome/common/extensions/url_pattern.h"
@@ skipping 65 matching lines @@
 }
 
 ExtensionInstallPrompt::Prompt::~Prompt() {
 }
 
 void ExtensionInstallPrompt::Prompt::SetPermissions(
     const std::vector<string16>& permissions) {
   permissions_ = permissions;
 }
 
+void ExtensionInstallPrompt::Prompt::SetOAuthIssueAdvice(
+    const IssueAdviceInfo& issue_advice) {
+  oauth_issue_advice_ = issue_advice;
+}
+
 void ExtensionInstallPrompt::Prompt::SetInlineInstallWebstoreData(
     const std::string& localized_user_count,
     double average_rating,
     int rating_count) {
   CHECK_EQ(INLINE_INSTALL_PROMPT, type_);
   localized_user_count_ = localized_user_count;
   average_rating_ = average_rating;
   rating_count_ = rating_count;
 }
 
@@ skipping 87 matching lines @@
 size_t ExtensionInstallPrompt::Prompt::GetPermissionCount() const {
   return permissions_.size();
 }
 
 string16 ExtensionInstallPrompt::Prompt::GetPermission(size_t index) const {
   CHECK_LT(index, permissions_.size());
   return l10n_util::GetStringFUTF16(
       IDS_EXTENSION_PERMISSION_LINE, permissions_[index]);
 }
 
+size_t ExtensionInstallPrompt::Prompt::GetOAuthIssueCount() const {
+  return oauth_issue_advice_.size();
+}
+
+const IssueAdviceInfoEntry& ExtensionInstallPrompt::Prompt::GetOAuthIssue(
+    size_t index) const {
+  CHECK_LT(index, oauth_issue_advice_.size());
+  return oauth_issue_advice_[index];
+}
+
 // static
 scoped_refptr<Extension>
     ExtensionInstallPrompt::GetLocalizedExtensionForDisplay(
     const DictionaryValue* manifest,
     const std::string& id,
     const std::string& localized_name,
     const std::string& localized_description,
     std::string* error) {
   scoped_ptr<DictionaryValue> localized_manifest;
   if (!localized_name.empty() || !localized_description.empty()) {
@@ skipping 11 matching lines @@
   return Extension::Create(
       FilePath(),
       Extension::INTERNAL,
       localized_manifest.get() ? *localized_manifest.get() : *manifest,
       Extension::NO_FLAGS,
       id,
       error);
 }
 
 ExtensionInstallPrompt::ExtensionInstallPrompt(Browser* browser)
-    : browser_(browser),
+    : record_oauth2_grant_(ShouldAutomaticallyApproveScopes()),
+      browser_(browser),
       ui_loop_(MessageLoop::current()),
       extension_(NULL),
       install_ui_(ExtensionInstallUI::Create(browser)),
       delegate_(NULL),
       prompt_(UNSET_PROMPT_TYPE),
       prompt_type_(UNSET_PROMPT_TYPE),
       ALLOW_THIS_IN_INITIALIZER_LIST(tracker_(this)) {
 }
 
 ExtensionInstallPrompt::~ExtensionInstallPrompt() {
 }
 
 void ExtensionInstallPrompt::ConfirmBundleInstall(
     extensions::BundleInstaller* bundle,
     const PermissionSet* permissions) {
   DCHECK(ui_loop_ == MessageLoop::current());
   bundle_ = bundle;
   permissions_ = permissions;
   delegate_ = bundle;
   prompt_type_ = BUNDLE_INSTALL_PROMPT;
 
-  ShowConfirmation();
+  FetchOAuthIssueAdviceIfNeeded();
 }
 
 void ExtensionInstallPrompt::ConfirmInlineInstall(
     Delegate* delegate,
     const Extension* extension,
     SkBitmap* icon,
     const ExtensionInstallPrompt::Prompt& prompt) {
   DCHECK(ui_loop_ == MessageLoop::current());
   extension_ = extension;
   permissions_ = extension->GetActivePermissions();
   delegate_ = delegate;
   prompt_ = prompt;
   prompt_type_ = INLINE_INSTALL_PROMPT;
 
   SetIcon(icon);
-  ShowConfirmation();
+  FetchOAuthIssueAdviceIfNeeded();
 }
 
 void ExtensionInstallPrompt::ConfirmWebstoreInstall(Delegate* delegate,
                                                     const Extension* extension,
                                                     const SkBitmap* icon) {
   // SetIcon requires |extension_| to be set. ConfirmInstall will setup the
   // remaining fields.
   extension_ = extension;
   SetIcon(icon);
   ConfirmInstall(delegate, extension);
@@ skipping 67 matching lines @@
   else
     icon_ = SkBitmap();
   if (icon_.empty())
     icon_ = Extension::GetDefaultIcon(extension_->is_app());
 }
 
 void ExtensionInstallPrompt::OnImageLoaded(const gfx::Image& image,
                                            const std::string& extension_id,
                                            int index) {
   SetIcon(image.IsEmpty() ? NULL : image.ToSkBitmap());
-  ShowConfirmation();
+  FetchOAuthIssueAdviceIfNeeded();
 }
 
 void ExtensionInstallPrompt::LoadImageIfNeeded() {
   // Bundle install prompts do not have an icon.
   if (!icon_.empty()) {
-    ShowConfirmation();
+    FetchOAuthIssueAdviceIfNeeded();
     return;
   }
 
   // Load the image asynchronously. For the response, check OnImageLoaded.
   ExtensionResource image =
       extension_->GetIconResource(ExtensionIconSet::EXTENSION_ICON_LARGE,
                                   ExtensionIconSet::MATCH_BIGGER);
   tracker_.LoadImage(extension_, image,
                      gfx::Size(kIconSize, kIconSize),
                      ImageLoadingTracker::DONT_CACHE);
 }
 
+void ExtensionInstallPrompt::FetchOAuthIssueAdviceIfNeeded() {
+  const Extension::OAuth2Info& oauth2_info = extension_->oauth2_info();
+  if (ShouldAutomaticallyApproveScopes() ||
+      oauth2_info.client_id.empty() ||
+      permissions_->scopes().empty() ||
+      prompt_type_ == BUNDLE_INSTALL_PROMPT ||
+      prompt_type_ == INLINE_INSTALL_PROMPT) {
+    ShowConfirmation();
+    return;
+  }
+
+  Profile* profile = install_ui_->browser()->profile();
+  TokenService* token_service = TokenServiceFactory::GetForProfile(profile);
+  std::vector<std::string> scopes;
+  scopes.assign(permissions_->scopes().begin(), permissions_->scopes().end());
+
+  token_flow_.reset(new OAuth2MintTokenFlow(
+      profile->GetRequestContext(),
+      this,
+      OAuth2MintTokenFlow::Parameters(
+          token_service->GetOAuth2LoginRefreshToken(),
+          extension_->id(),
+          oauth2_info.client_id,
+          scopes,
+          OAuth2MintTokenFlow::MODE_ISSUE_ADVICE)));
+  token_flow_->Start();
+}
+
+void ExtensionInstallPrompt::OnIssueAdviceSuccess(
+    const IssueAdviceInfo& advice_info) {
+  prompt_.SetOAuthIssueAdvice(advice_info);
+  record_oauth2_grant_ = true;
+  ShowConfirmation();
+}
+
+void ExtensionInstallPrompt::OnMintTokenFailure(
+    const GoogleServiceAuthError& error) {
+  ShowConfirmation();
+}
+
 void ExtensionInstallPrompt::ShowConfirmation() {
   prompt_.set_type(prompt_type_);
   prompt_.SetPermissions(permissions_->GetWarningMessages());
 
   switch (prompt_type_) {
     case PERMISSIONS_PROMPT:
     case RE_ENABLE_PROMPT:
     case INLINE_INSTALL_PROMPT:
     case INSTALL_PROMPT: {
       prompt_.set_extension(extension_);
       prompt_.set_icon(gfx::Image(icon_));
       ShowExtensionInstallDialog(browser_, delegate_, prompt_);
       break;
     }
     case BUNDLE_INSTALL_PROMPT: {
       prompt_.set_bundle(bundle_);
       ShowExtensionInstallDialog(browser_, delegate_, prompt_);
       break;
     }
     default:
       NOTREACHED() << "Unknown message";
       break;
   }
 }
+
+// static
+bool ExtensionInstallPrompt::ShouldAutomaticallyApproveScopes() {
+  return !CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kDemandUserScopeApproval);
+}