Modify experimental identity flow to display scope descriptions and details.

chrome/browser/extensions/extension_install_prompt.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_INSTALL_PROMPT_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_INSTALL_PROMPT_H_
 #pragma once
 
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/string16.h"
 #include "chrome/browser/extensions/crx_installer_error.h"
 #include "chrome/browser/extensions/image_loading_tracker.h"
 #include "chrome/common/extensions/url_pattern.h"
+#include "chrome/common/net/gaia/oauth2_mint_token_flow.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/native_widget_types.h"
 
 class Browser;
 class ExtensionInstallUI;
 class ExtensionPermissionSet;
 class MessageLoop;
 class InfoBarDelegate;
 
 namespace base {
 class DictionaryValue;
 }  // namespace base
 
 namespace extensions {
 class BundleInstaller;
 class Extension;
 class ExtensionWebstorePrivateApiTest;
 }  // namespace extensions
 
 // Displays all the UI around extension installation.
-class ExtensionInstallPrompt : public ImageLoadingTracker::Observer {
+class ExtensionInstallPrompt : public ImageLoadingTracker::Observer,
+                               public OAuth2MintTokenFlow::Delegate {
  public:
   enum PromptType {
     UNSET_PROMPT_TYPE = -1,
     INSTALL_PROMPT = 0,
     INLINE_INSTALL_PROMPT,
     BUNDLE_INSTALL_PROMPT,
     RE_ENABLE_PROMPT,
     PERMISSIONS_PROMPT,
     NUM_PROMPT_TYPES
   };
 
   // Extra information needed to display an installation or uninstallation
   // prompt. Gets populated with raw data and exposes getters for formatted
   // strings so that the GTK/views/Cocoa install dialogs don't have to repeat
   // that logic.
   class Prompt {
    public:
     explicit Prompt(PromptType type);
     ~Prompt();
 
     void SetPermissions(const std::vector<string16>& permissions);
     void SetInlineInstallWebstoreData(const std::string& localized_user_count,
                                       double average_rating,
                                       int rating_count);
+    void SetOAuthIssues(const IssueAdviceInfo& issues);
 
     PromptType type() const { return type_; }
     void set_type(PromptType type) { type_ = type; }
 
     // Getters for UI element labels.
     string16 GetDialogTitle() const;
     string16 GetHeading() const;
     string16 GetAcceptButtonLabel() const;
     bool HasAbortButtonLabel() const;
     string16 GetAbortButtonLabel() const;
     string16 GetPermissionsHeading() const;
 
     // Getters for webstore metadata. Only populated when the type is
     // INLINE_INSTALL_PROMPT.
 
     // The star display logic replicates the one used by the webstore (from
     // components.ratingutils.setFractionalYellowStars). Callers pass in an
     // "appender", which will be repeatedly called back with the star images
     // that they append to the star display area.
     typedef void(*StarAppender)(const gfx::ImageSkia*, void*);
     void AppendRatingStars(StarAppender appender, void* data) const;
     string16 GetRatingCount() const;
     string16 GetUserCount() const;
     size_t GetPermissionCount() const;
     string16 GetPermission(size_t index) const;
+    size_t GetOAuthIssueCount() const;
+    const IssueAdviceInfoEntry& GetOAuthIssue(size_t index) const;
 
     // Populated for BUNDLE_INSTALL_PROMPT.
     const extensions::BundleInstaller* bundle() const { return bundle_; }
     void set_bundle(const extensions::BundleInstaller* bundle) {
       bundle_ = bundle;
     }
 
     // Populated for all other types.
     const extensions::Extension* extension() const { return extension_; }
     void set_extension(const extensions::Extension* extension) {
       extension_ = extension;
     }
 
     const gfx::Image& icon() const { return icon_; }
     void set_icon(const gfx::Image& icon) { icon_ = icon; }
 
    private:
     PromptType type_;
     // Permissions that are being requested (may not be all of an extension's
     // permissions if only additional ones are being requested)
     std::vector<string16> permissions_;
 
+    // Descriptions and details for OAuth2 permissions to display to the user.
+    // These correspond to permission scopes.
+    IssueAdviceInfo oauth_issues_;
+
     // The extension or bundle being installed.
     const extensions::Extension* extension_;
     const extensions::BundleInstaller* bundle_;
 
     // The icon to be displayed.
     gfx::Image icon_;
 
     // These fields are populated only when the prompt type is
     // INLINE_INSTALL_PROMPT
     // Already formatted to be locale-specific.
@@ skipping 26 matching lines @@
       const std::string& id,
       const std::string& localized_name,
       const std::string& localized_description,
       std::string* error);
 
   explicit ExtensionInstallPrompt(Browser* browser);
   virtual ~ExtensionInstallPrompt();
 
   ExtensionInstallUI* install_ui() const { return install_ui_.get(); }
 
+  bool record_oauth2_grant() const { return record_oauth2_grant_; }
+
   // This is called by the bundle installer to verify whether the bundle
   // should be installed.
   //
   // We *MUST* eventually call either Proceed() or Abort() on |delegate|.
   virtual void ConfirmBundleInstall(extensions::BundleInstaller* bundle,
                                     const ExtensionPermissionSet* permissions);
 
   // This is called by the inline installer to verify whether the inline
   // install from the webstore should proceed.
   //
@@ skipping 54 matching lines @@
 
   // Sets the icon that will be used in any UI. If |icon| is NULL, or contains
   // an empty bitmap, then a default icon will be used instead.
   void SetIcon(const SkBitmap* icon);
 
   // Starts the process of showing a confirmation UI, which is split into two.
   // 1) Set off a 'load icon' task.
   // 2) Handle the load icon response and show the UI (OnImageLoaded).
   void LoadImageIfNeeded();
 
+  // Starts fetching warnings for OAuth2 scopes, if there are any.
+  void FetchOAuthIssuesIfNeeded();

[jstritar, 2012/06/25 15:10:35]

Nice, glad you moved this in here... seems like the right place.

[Munjal (Google), 2012/06/25 20:40:09]

Nit: Can we name this FetchOAuthIssueAdviceIfNeeded?

"Issues" is a misnomer here. What we are fetching are messages we should show to
the user to get the user's consent. That is called "issue advice" by the oauth
team.

[Evan Stade, 2012/06/26 00:56:03]

changed here and elsewhere.

+
+  // OAuth2MintTokenFlow::Delegate implementation:
+  virtual void OnIssueAdviceSuccess(
+      const IssueAdviceInfo& issue_advice) OVERRIDE;
+  virtual void OnMintTokenFailure(
+      const GoogleServiceAuthError& error) OVERRIDE;
+
   // Shows the actual UI (the icon should already be loaded).
   void ShowConfirmation();
 
   Browser* browser_;
   MessageLoop* ui_loop_;
 
   // The extensions installation icon.
   SkBitmap icon_;
 
   // The extension we are showing the UI for.
@@ skipping 10 matching lines @@
 
   // The delegate we will call Proceed/Abort on after confirmation UI.
   Delegate* delegate_;
 
   // A pre-filled prompt.
   Prompt prompt_;
 
   // The type of prompt we are going to show.
   PromptType prompt_type_;
 
+  // Whether or not we should record the oauth2 grant upon successful install.
+  bool record_oauth2_grant_;
+
+  scoped_refptr<OAuth2MintTokenFlow> token_flow_;
+
   // Keeps track of extension images being loaded on the File thread for the
   // purpose of showing the install UI.
   ImageLoadingTracker tracker_;
 };
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_INSTALL_PROMPT_H_