Add an extension bubble explaining which extensions are in dev mode.

chrome/browser/extensions/dev_mode_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_DEV_MODE_BUBBLE_CONTROLLER_H_
+#define CHROME_BROWSER_EXTENSIONS_DEV_MODE_BUBBLE_CONTROLLER_H_
+
+#include <string>
+#include "chrome/browser/extensions/api/profile_keyed_api_factory.h"
+#include "chrome/browser/extensions/extension_message_bubble_controller.h"
+#include "content/public/browser/notification_observer.h"
+#include "content/public/browser/notification_registrar.h"
+#include "extensions/common/extension.h"
+
+class Browser;
+class ExtensionService;
+
+namespace extensions {
+
+class DevModeBubble;
+
+class DevModeBubbleController
+    : public ProfileKeyedAPI,
+      public ExtensionMessageBubbleController,

[not at google - send to devlin, 2013/12/12 18:21:38]

The only reason to extend ExtensionMessageBubbleController here is so that you
can pass it around as a Controller, right? And the only reason you need to do
that is because you need to make sure they only show once per profile, so you
make them singletons on profile?

It would be really nice to implement that some other way, because having this
extend both the Controller *and* its delegate is a pretty weird pattern. It's
also a bit inflexible (basically means that every Delegate needs to be
ProfileKeyed or at least have lifetime tied to something else). This is what I
would hope works:

- Make ExtensionMessageBubbleController take *ownership* of its Delegate
- Make ExtensionMessageBubbleView take *ownership* of its Controller
- To implement profile-singleton-ness implement it per-Delegate, that is, pull
ShouldShow implementation out of the Controller and into the delegate. The
controller's ShouldShow doesn't actually do very much.

Is there some reason that wouldn't work? ShouldShow would be pretty trivial to
implement:

#include "base/lazy_instance.h"
base::LazyInstance<std::set<Profile*> > g_shown_for_profiles =
    LAZY_INSTANCE_INITIALIZER;
bool Delegate::ShouldShow() {
  // both Delegates would have this exact implementation, but future
  // Delegates might not, and that would be flexible.
  return g_shown_for_profiles.Get().count(profile_) && !GetExtensions().empty();
}

I think this would be a pretty mechanical change.

Actually - since GetExtensions() will hopefully go away, if ShouldShow is put on
the Delegate then it won't be able to take that into account. Perhaps ShouldShow
needs to stay on the Controller but you need a second method like
ShouldShowForDelegate or something on these Delegate methods.

Eh, a little more complicated, but even that would be a lot simpler than this
ProfileKeyedAPI approach.

+      public ExtensionMessageBubbleController::Delegate {
+ public:
+  explicit DevModeBubbleController(Profile* profile);
+  virtual ~DevModeBubbleController();
+
+  // ProfileKeyedAPI implementation.
+  static ProfileKeyedAPIFactory<
+      DevModeBubbleController>* GetFactoryInstance();
+
+  // Convenience method to get the DevModeBubbleController for a
+  // profile.
+  static DevModeBubbleController* Get(Profile* profile);
+
+  // Returns true if the extension is considered a Developer Mode extension.
+  bool IsDevModeExtension(const Extension* extension) const;
+
+  // ExtensionMessageBubbleController::Delegate methods.
+  virtual bool ShouldIncludeExtension(const std::string& extension_id) OVERRIDE;
+  virtual void AcknowledgeExtension(
+      const std::string& extension_id,
+      ExtensionMessageBubbleController::BubbleAction user_action) OVERRIDE;
+  virtual void PerformAction(const ExtensionIdList& list) OVERRIDE;
+  virtual string16 GetTitle() const OVERRIDE;
+  virtual string16 GetMessageBody() const OVERRIDE;
+  virtual string16 GetOverflowText(
+      const string16& overflow_count) const OVERRIDE;
+  virtual string16 GetLearnMoreLabel() const OVERRIDE;
+  virtual GURL GetLearnMoreUrl() const OVERRIDE;
+  virtual string16 GetActionButtonLabel() const OVERRIDE;
+  virtual string16 GetDismissButtonLabel() const OVERRIDE;
+  virtual bool ShouldShowExtensionList() const OVERRIDE;
+  virtual std::vector<string16> GetExtensions() OVERRIDE;
+  virtual void LogExtensionCount(size_t count) OVERRIDE;
+  virtual void LogAction(
+      ExtensionMessageBubbleController::BubbleAction action) OVERRIDE;
+
+ private:
+  friend class ProfileKeyedAPIFactory<DevModeBubbleController>;
+
+  // ProfileKeyedAPI implementation.
+  static const char* service_name() {
+    return "DevModeBubbleController";
+  }
+  static const bool kServiceRedirectedInIncognito = true;
+
+  // Our extension service. Weak, not owned by us.
+  ExtensionService* service_;
+
+  // A weak pointer to the profile we are associated with. Not owned by us.
+  Profile* profile_;
+
+
+  DISALLOW_COPY_AND_ASSIGN(DevModeBubbleController);
+};
+
+template <>
+void ProfileKeyedAPIFactory<
+    DevModeBubbleController>::DeclareFactoryDependencies();
+
+}  // namespace extensions
+
+#endif  // CHROME_BROWSER_EXTENSIONS_DEV_MODE_BUBBLE_CONTROLLER_H_