Revert r 144574 "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)
-    : record_oauth2_grant_(ShouldAutomaticallyApproveScopes()),
-      browser_(browser),
+    : 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;
 
-  FetchOAuthIssueAdviceIfNeeded();
+  ShowConfirmation();
 }
 
 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);
-  FetchOAuthIssueAdviceIfNeeded();
+  ShowConfirmation();
 }
 
 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());
-  FetchOAuthIssueAdviceIfNeeded();
+  ShowConfirmation();
 }
 
 void ExtensionInstallPrompt::LoadImageIfNeeded() {
   // Bundle install prompts do not have an icon.
   if (!icon_.empty()) {
-    FetchOAuthIssueAdviceIfNeeded();
+    ShowConfirmation();
     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);
-}