[Reland][Extensions] Don't count bubble focus loss as acknowledgment

chrome/browser/extensions/extension_message_bubble_controller.h

 // Copyright (c) 2013 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_MESSAGE_BUBBLE_CONTROLLER_H_
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_MESSAGE_BUBBLE_CONTROLLER_H_
 
 #include <string>
 #include "extensions/browser/browser_context_keyed_api_factory.h"
 #include "extensions/common/extension.h"
 
 class Browser;
 class ExtensionService;
 class Profile;
 
 namespace extensions {
 
 class ExtensionPrefs;
 class ExtensionRegistry;
 
 class ExtensionMessageBubbleController {
  public:
   // UMA histogram constants.
   enum BubbleAction {
     ACTION_LEARN_MORE = 0,
     ACTION_EXECUTE,
-    ACTION_DISMISS,
-    ACTION_BOUNDARY, // Must be the last value.
+    ACTION_DISMISS_USER_ACTION,
+    ACTION_DISMISS_DEACTIVATION,
+    ACTION_BOUNDARY,  // Must be the last value.
   };
 
   class Delegate {
    public:
     explicit Delegate(Profile* profile);
     virtual ~Delegate();
 
     virtual bool ShouldIncludeExtension(const Extension* extension) = 0;
     virtual void AcknowledgeExtension(
         const std::string& extension_id,
@@ skipping 28 matching lines @@
     // the toolbar.
     virtual bool ShouldHighlightExtensions() const = 0;
 
     // Returns true if only enabled extensions should be considered.
     virtual bool ShouldLimitToEnabledExtensions() const = 0;
 
     // Record, through UMA, how many extensions were found.
     virtual void LogExtensionCount(size_t count) = 0;
     virtual void LogAction(BubbleAction action) = 0;
 
+    // Returns a key unique to the type of bubble that can be used to retrieve
+    // state specific to the type (e.g., shown for profiles).
+    virtual const char* GetKey() = 0;
+
+    // Whether the "shown for profiles" set should be cleared if an action is
+    // taken on the bubble. This defaults to true, since once an action is
+    // taken, the extension will usually either be acknowledged or removed, and
+    // the bubble won't show for that extension.
+    // This should be false in cases where there is no acknowledgment option
+    // (as in the developer-mode extension warning).
+    virtual bool ClearProfileSetAfterAction();
+
     // Has the user acknowledged info about the extension the bubble reports.
-    virtual bool HasBubbleInfoBeenAcknowledged(const std::string& extension_id);
-    virtual void SetBubbleInfoBeenAcknowledged(const std::string& extension_id,
-                                               bool value);
-
-    // Returns the set of profiles for which this bubble has been shown.
-    // If profiles are not tracked, returns null (default).
-    virtual std::set<Profile*>* GetProfileSet();
+    bool HasBubbleInfoBeenAcknowledged(const std::string& extension_id);
+    void SetBubbleInfoBeenAcknowledged(const std::string& extension_id,
+                                       bool value);
 
    protected:
     Profile* profile() { return profile_; }
     ExtensionService* service() { return service_; }
     const ExtensionRegistry* registry() const { return registry_; }
 
     std::string get_acknowledged_flag_pref_name() const;
     void set_acknowledged_flag_pref_name(const std::string& pref_name);
 
    private:
@@ skipping 39 matching lines @@
   // Highlights the affected extensions if appropriate. Safe to call multiple
   // times.
   void HighlightExtensionsIfNecessary();
 
   // Called when the bubble is actually shown. Because some bubbles are delayed
   // (in order to weather the "focus storm"), they are not shown immediately.
   void OnShown();
 
   // Callbacks from bubble. Declared virtual for testing purposes.
   virtual void OnBubbleAction();
-  virtual void OnBubbleDismiss();
+  virtual void OnBubbleDismiss(bool dismissed_by_deactivation);
   virtual void OnLinkClicked();
 
+  void ClearProfileListForTesting();
+
   static void set_should_ignore_learn_more_for_testing(
       bool should_ignore_learn_more);
 
  private:
   // Iterate over the known extensions and acknowledge each one.
   void AcknowledgeExtensions();
 
   // Get the data this class needs.
   ExtensionIdList* GetOrCreateExtensionList();
 
   // Performs cleanup after the bubble closes.
   void OnClose();
 
+  std::set<Profile*>* GetProfileSet();
+
   // A weak pointer to the Browser we are associated with. Not owned by us.
   Browser* browser_;
 
   // The list of extensions found.
   ExtensionIdList extension_list_;
 
   // The action the user took in the bubble.
   BubbleAction user_action_;
 
   // Our delegate supplying information about what to show in the dialog.
   scoped_ptr<Delegate> delegate_;
 
   // Whether this class has initialized.
   bool initialized_;
 
   // Whether or not the bubble is highlighting extensions.
   bool did_highlight_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionMessageBubbleController);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_MESSAGE_BUBBLE_CONTROLLER_H_