Add an extension override bubble and warning box for proxy extensions.

chrome/browser/ui/views/extensions/extension_message_bubble_view.cc

 // 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.
 
 #include "chrome/browser/ui/views/extensions/extension_message_bubble_view.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/dev_mode_bubble_controller.h"
 #include "chrome/browser/extensions/extension_action_manager.h"
 #include "chrome/browser/extensions/extension_message_bubble_controller.h"
 #include "chrome/browser/extensions/extension_service.h"
+#include "chrome/browser/extensions/proxy_overridden_bubble_controller.h"
 #include "chrome/browser/extensions/settings_api_bubble_controller.h"
 #include "chrome/browser/extensions/settings_api_helpers.h"
 #include "chrome/browser/extensions/suspicious_extension_bubble_controller.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/view_ids.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/toolbar/browser_actions_container.h"
 #include "chrome/browser/ui/views/toolbar/browser_actions_container_observer.h"
 #include "chrome/browser/ui/views/toolbar/toolbar_view.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_system.h"
 #include "grit/locale_settings.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/views/controls/button/label_button.h"
@@ skipping 27 matching lines @@
 
 namespace extensions {
 
 ExtensionMessageBubbleView::ExtensionMessageBubbleView(
     views::View* anchor_view,
     views::BubbleBorder::Arrow arrow_location,
     scoped_ptr<extensions::ExtensionMessageBubbleController> controller)
     : BubbleDelegateView(anchor_view, arrow_location),
       weak_factory_(this),
       controller_(controller.Pass()),
+      anchor_view_(anchor_view),
       headline_(NULL),
       learn_more_(NULL),
       dismiss_button_(NULL),
       link_clicked_(false),
       action_taken_(false) {
   DCHECK(anchor_view->GetWidget());
   set_close_on_deactivate(controller_->CloseOnDeactivate());
   set_close_on_esc(true);
 
   // Compensate for built-in vertical padding in the anchor view's image.
@@ skipping 74 matching lines @@
   const int text_column_set_id = 1;
   views::ColumnSet* upper_columns = layout->AddColumnSet(text_column_set_id);
   upper_columns->AddColumn(
       views::GridLayout::LEADING, views::GridLayout::LEADING,
       0, views::GridLayout::USE_PREF, 0, 0);
   layout->StartRow(0, text_column_set_id);
 
   views::Label* message = new views::Label();
   message->SetMultiLine(true);
   message->SetHorizontalAlignment(gfx::ALIGN_LEFT);
-  message->SetText(delegate->GetMessageBody());
+  message->SetText(delegate->GetMessageBody(
+      anchor_view_->id() == VIEW_ID_BROWSER_ACTION));
   message->SizeToFit(views::Widget::GetLocalizedContentsWidth(
       IDS_EXTENSION_WIPEOUT_BUBBLE_WIDTH_CHARS));
   layout->AddView(message);
 
   if (delegate->ShouldShowExtensionList()) {
     const int extension_list_column_set_id = 2;
     views::ColumnSet* middle_columns =
         layout->AddColumnSet(extension_list_column_set_id);
     middle_columns->AddPaddingColumn(0, kExtensionListPadding);
     middle_columns->AddColumn(
@@ skipping 95 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // ExtensionMessageBubbleFactory
 
 ExtensionMessageBubbleFactory::ExtensionMessageBubbleFactory(
     Profile* profile,
     ToolbarView* toolbar_view)
     : profile_(profile),
       toolbar_view_(toolbar_view),
       shown_suspicious_extensions_bubble_(false),
       shown_startup_override_extensions_bubble_(false),
+      shown_proxy_override_extensions_bubble_(false),
       shown_dev_mode_extensions_bubble_(false),
       is_observing_(false),
       stage_(STAGE_START),
       container_(NULL),
       anchor_view_(NULL) {}
 
 ExtensionMessageBubbleFactory::~ExtensionMessageBubbleFactory() {
   MaybeStopObserving();
 }
 
@@ skipping 12 matching lines @@
   // way, we're not too spammy with the bubbles.
   if (!shown_suspicious_extensions_bubble_ &&
       MaybeShowSuspiciousExtensionsBubble(anchor_view))
     return;
 
   if (!shown_startup_override_extensions_bubble_ &&
       is_initial_check &&
       MaybeShowStartupOverrideExtensionsBubble(anchor_view))
     return;
 
+  if (!shown_proxy_override_extensions_bubble_ &&
+      MaybeShowProxyOverrideExtensionsBubble(anchor_view))
+    return;
+
   if (!shown_dev_mode_extensions_bubble_)
     MaybeShowDevModeExtensionsBubble(anchor_view);
 #endif  // OS_WIN
 }
 
 bool ExtensionMessageBubbleFactory::MaybeShowSuspiciousExtensionsBubble(
     views::View* anchor_view) {
   DCHECK(!shown_suspicious_extensions_bubble_);
 
   scoped_ptr<SuspiciousExtensionBubbleController> suspicious_extensions(
@@ skipping 12 matching lines @@
   views::BubbleDelegateView::CreateBubble(bubble_delegate);
   weak_controller->Show(bubble_delegate);
 
   return true;
 }
 
 bool ExtensionMessageBubbleFactory::MaybeShowStartupOverrideExtensionsBubble(
     views::View* anchor_view) {
 #if !defined(OS_WIN)
   return false;
-#endif
-
+#else
   DCHECK(!shown_startup_override_extensions_bubble_);
 
-  const Extension* extension = OverridesStartupPages(profile_, NULL);
+  const Extension* extension =
+      GetExtensionOverridingStartupPages(profile_, NULL);
   if (!extension)
     return false;
 
   scoped_ptr<SettingsApiBubbleController> settings_api_bubble(
       new SettingsApiBubbleController(profile_,
                                       BUBBLE_TYPE_STARTUP_PAGES));
   if (!settings_api_bubble->ShouldShow(extension->id()))
     return false;
 
   shown_startup_override_extensions_bubble_ = true;
-  SettingsApiBubbleController* weak_controller = settings_api_bubble.get();
-  ExtensionMessageBubbleView* bubble_delegate = new ExtensionMessageBubbleView(
-      anchor_view,
-      views::BubbleBorder::TOP_RIGHT,
-      settings_api_bubble.PassAs<ExtensionMessageBubbleController>());
-  views::BubbleDelegateView::CreateBubble(bubble_delegate);
-  weak_controller->Show(bubble_delegate);
+  PrepareToHighlightExtensions(
+      settings_api_bubble.PassAs<ExtensionMessageBubbleController>(),
+      anchor_view);
+  return true;
+#endif
+}
 
+bool ExtensionMessageBubbleFactory::MaybeShowProxyOverrideExtensionsBubble(
+    views::View* anchor_view) {
+#if !defined(OS_WIN)
+  return false;
+#else
+  DCHECK(!shown_proxy_override_extensions_bubble_);
+
+  const Extension* extension = GetExtensionOverridingProxy(profile_);
+  if (!extension)
+    return false;
+
+  scoped_ptr<ProxyOverriddenBubbleController> proxy_bubble(
+      new ProxyOverriddenBubbleController(profile_));
+  if (!proxy_bubble->ShouldShow(extension->id()))
+    return false;
+
+  shown_proxy_override_extensions_bubble_ = true;
+  PrepareToHighlightExtensions(
+      proxy_bubble.PassAs<ExtensionMessageBubbleController>(), anchor_view);
   return true;
+#endif
 }
 
 bool ExtensionMessageBubbleFactory::MaybeShowDevModeExtensionsBubble(
     views::View* anchor_view) {
   DCHECK(!shown_dev_mode_extensions_bubble_);
 
   // Check the Developer Mode extensions.
   scoped_ptr<DevModeBubbleController> dev_mode_extensions(
       new DevModeBubbleController(profile_));
 
   // Return early if we have none to show.
   if (!dev_mode_extensions->ShouldShow())
     return false;
 
   shown_dev_mode_extensions_bubble_ = true;
-
-  // We should be in the start stage (i.e., should not have a pending attempt to
-  // show a bubble).
-  DCHECK_EQ(stage_, STAGE_START);
-
-  // Prepare to display and highlight the developer mode extensions before
-  // showing the bubble. Since this is an asynchronous process, set member
-  // variables for later use.
-  controller_ = dev_mode_extensions.Pass();
-  anchor_view_ = anchor_view;
-  container_ = toolbar_view_->browser_actions();
-
-  if (container_->animating())
-    MaybeObserve();
-  else
-    HighlightDevModeExtensions();
-
+  PrepareToHighlightExtensions(
+      dev_mode_extensions.PassAs<ExtensionMessageBubbleController>(),
+      anchor_view);
   return true;
 }
 
 void ExtensionMessageBubbleFactory::MaybeObserve() {
   if (!is_observing_) {
     is_observing_ = true;
     container_->AddObserver(this);
   }
 }
 
 void ExtensionMessageBubbleFactory::MaybeStopObserving() {
   if (is_observing_) {
     is_observing_ = false;
     container_->RemoveObserver(this);
   }
 }
 
 void ExtensionMessageBubbleFactory::RecordProfileCheck(Profile* profile) {
   g_profiles_evaluated.Get().insert(profile);
 }
 
 bool ExtensionMessageBubbleFactory::IsInitialProfileCheck(Profile* profile) {
   return g_profiles_evaluated.Get().count(profile) == 0;
 }
 
 void ExtensionMessageBubbleFactory::OnBrowserActionsContainerAnimationEnded() {
   MaybeStopObserving();
   if (stage_ == STAGE_START) {
-    HighlightDevModeExtensions();
+    HighlightExtensions();
   } else if (stage_ == STAGE_HIGHLIGHTED) {
-    ShowDevModeBubble();
+    ShowHighlightingBubble();
   } else {  // We shouldn't be observing if we've completed the process.
     NOTREACHED();
     Finish();
   }
 }
 
 void ExtensionMessageBubbleFactory::OnBrowserActionsContainerDestroyed() {
   // If the container associated with the bubble is destroyed, abandon the
   // process.
   Finish();
 }
 
-void ExtensionMessageBubbleFactory::HighlightDevModeExtensions() {
+void ExtensionMessageBubbleFactory::PrepareToHighlightExtensions(
+    scoped_ptr<ExtensionMessageBubbleController> controller,
+    views::View* anchor_view) {
+  // We should be in the start stage (i.e., should not have a pending attempt to
+  // show a bubble).
+  DCHECK_EQ(stage_, STAGE_START);
+
+  // Prepare to display and highlight the extensions before showing the bubble.
+  // Since this is an asynchronous process, set member variables for later use.
+  controller_ = controller.Pass();
+  anchor_view_ = anchor_view;
+  container_ = toolbar_view_->browser_actions();
+
+  if (container_->animating())
+    MaybeObserve();
+  else
+    HighlightExtensions();
+}
+
+void ExtensionMessageBubbleFactory::HighlightExtensions() {
   DCHECK_EQ(STAGE_START, stage_);
   stage_ = STAGE_HIGHLIGHTED;
 
   const ExtensionIdList extension_list = controller_->GetExtensionIdList();
   DCHECK(!extension_list.empty());
   ExtensionToolbarModel::Get(profile_)->HighlightExtensions(extension_list);
   if (container_->animating())
     MaybeObserve();
   else
-    ShowDevModeBubble();
+    ShowHighlightingBubble();
 }
 
-void ExtensionMessageBubbleFactory::ShowDevModeBubble() {
+void ExtensionMessageBubbleFactory::ShowHighlightingBubble() {
   DCHECK_EQ(stage_, STAGE_HIGHLIGHTED);
   stage_ = STAGE_COMPLETE;
 
   views::View* reference_view = NULL;
   if (container_->num_browser_actions() > 0)
     reference_view = container_->GetBrowserActionViewAt(0);
   if (reference_view && reference_view->visible())
     anchor_view_ = reference_view;
 
-  DevModeBubbleController* weak_controller = controller_.get();
-  ExtensionMessageBubbleView* bubble_delegate = new ExtensionMessageBubbleView(
-      anchor_view_,
-      views::BubbleBorder::TOP_RIGHT,
-      scoped_ptr<ExtensionMessageBubbleController>(controller_.release()));
+  ExtensionMessageBubbleController* weak_controller = controller_.get();
+  ExtensionMessageBubbleView* bubble_delegate =
+      new ExtensionMessageBubbleView(
+          anchor_view_,
+          views::BubbleBorder::TOP_RIGHT,
+          scoped_ptr<ExtensionMessageBubbleController>(
+              controller_.release()));
   views::BubbleDelegateView::CreateBubble(bubble_delegate);
   weak_controller->Show(bubble_delegate);
 
   Finish();
 }
 
 void ExtensionMessageBubbleFactory::Finish() {
   MaybeStopObserving();
   controller_.reset();
   anchor_view_ = NULL;
   container_ = NULL;
 }
 
 }  // namespace extensions