First cut of the about:conflicts page, listing all DLLs loaded in the Chrome ...

chrome/browser/views/toolbar_view.cc

 // Copyright (c) 2010 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/views/toolbar_view.h"
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/accessibility/browser_accessibility_state.h"
@@ skipping 23 matching lines @@
 #include "views/window/window.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/cros/update_library.h"
 #include "chrome/browser/chromeos/dom_ui/wrench_menu_ui.h"
 #include "views/controls/menu/menu_2.h"
 #endif
 #include "chrome/browser/views/wrench_menu.h"
 
+#if defined(OS_WIN)
+#include "chrome/browser/enumerate_modules_model_win.h"
+#endif
+
 // The space between items is 4 px in general.
 const int ToolbarView::kStandardSpacing = 4;
 // The top of the toolbar has an edge we have to skip over in addition to the 4
 // px of spacing.
 const int ToolbarView::kVertSpacing = kStandardSpacing + 1;
 // The edge graphics have some built-in spacing/shadowing, so we have to adjust
 // our spacing to make it still appear to be 4 px.
 static const int kEdgeSpacing = ToolbarView::kStandardSpacing - 1;
 // The buttons to the left of the omnibox are close together.
 static const int kButtonSpacing = 1;
@@ skipping 41 matching lines @@
 
   if (!kPopupBackgroundEdge) {
     kPopupBackgroundEdge = ResourceBundle::GetSharedInstance().GetBitmapNamed(
         IDR_LOCATIONBG_POPUPMODE_EDGE);
   }
 
   if (!IsUpgradeRecommended()) {
     registrar_.Add(this, NotificationType::UPGRADE_RECOMMENDED,
                    NotificationService::AllSources());
   }
+  registrar_.Add(this, NotificationType::MODULE_INCOMPATIBILITY_DETECTED,
+                 NotificationService::AllSources());
 }
 
 ToolbarView::~ToolbarView() {
   if (destroyed_flag_)
     *destroyed_flag_ = true;
 
   // NOTE: Don't remove the command observers here.  This object gets destroyed
   // after the Browser (which owns the CommandUpdater), so the CommandUpdater is
   // already gone.
 }
@@ skipping 53 matching lines @@
 
   app_menu_ = new views::MenuButton(NULL, std::wstring(), this, false);
   app_menu_->set_border(NULL);
   app_menu_->EnableCanvasFlippingForRTLUI(true);
   app_menu_->SetAccessibleName(l10n_util::GetString(IDS_ACCNAME_APP));
   app_menu_->SetTooltipText(l10n_util::GetStringF(IDS_APPMENU_TOOLTIP,
       l10n_util::GetString(IDS_PRODUCT_NAME)));
   app_menu_->SetID(VIEW_ID_APP_MENU);
 
   // Catch the case where the window is created after we detect a new version.
-  if (IsUpgradeRecommended())
-    ShowUpgradeReminder();
+  if (IsUpgradeRecommended() || ShouldShowIncompatibilityWarning())
+    ShowNotificationDot();
 
   LoadImages();
 
   // Always add children in order from left to right, for accessibility.
   AddChildView(back_);
   AddChildView(forward_);
   AddChildView(reload_);
   AddChildView(home_);
   AddChildView(location_bar_);
   AddChildView(browser_actions_);
@@ skipping 120 matching lines @@
 
   wrench_menu_->RunMenu(app_menu_);
 
 #if defined(OS_CHROMEOS)
 cleanup:
 #endif
   if (destroyed_flag)
     return;
   destroyed_flag_ = NULL;
 
-  // Stop pulsating the upgrade reminder on the app menu, if active.
-  upgrade_reminder_pulse_timer_.Stop();
+  // Stop pulsating the notification dot on the app menu (if active).
+  notification_dot_pulse_timer_.Stop();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ToolbarView, LocationBarView::Delegate implementation:
 
 TabContents* ToolbarView::GetTabContents() {
   return browser_->GetSelectedTabContents();
 }
 
 InstantController* ToolbarView::GetInstant() {
@@ skipping 62 matching lines @@
 void ToolbarView::Observe(NotificationType type,
                           const NotificationSource& source,
                           const NotificationDetails& details) {
   if (type == NotificationType::PREF_CHANGED) {
     std::string* pref_name = Details<std::string>(details).ptr();
     if (*pref_name == prefs::kShowHomeButton) {
       Layout();
       SchedulePaint();
     }
   } else if (type == NotificationType::UPGRADE_RECOMMENDED) {
-    ShowUpgradeReminder();
+    ShowNotificationDot();
+  } else if (type == NotificationType::MODULE_INCOMPATIBILITY_DETECTED) {
+    bool confirmed_bad = *Details<bool>(details).ptr();
+    if (confirmed_bad)
+      ShowNotificationDot();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ToolbarView, menus::AcceleratorProvider implementation:
 
 bool ToolbarView::GetAcceleratorForCommandId(int command_id,
     menus::Accelerator* accelerator) {
   // The standard Ctrl-X, Ctrl-V and Ctrl-C are not defined as accelerators
   // anywhere so we need to check for them explicitly here.
@@ skipping 158 matching lines @@
 
 bool ToolbarView::IsUpgradeRecommended() {
 #if defined(OS_CHROMEOS)
   return (chromeos::CrosLibrary::Get()->GetUpdateLibrary()->status().status ==
           chromeos::UPDATE_STATUS_UPDATED_NEED_REBOOT);
 #else
   return (Singleton<UpgradeDetector>::get()->notify_upgrade());
 #endif
 }
 
+bool ToolbarView::ShouldShowIncompatibilityWarning() {
+#if defined(OS_WIN)
+  EnumerateModulesModel* loaded_modules = EnumerateModulesModel::GetSingleton();
+  return loaded_modules->confirmed_bad_modules_detected() > 0;
+#else
+  return false;
+#endif
+}
+
 int ToolbarView::PopupTopSpacing() const {
   return GetWindow()->GetNonClientView()->UseNativeFrame() ?
       0 : kPopupTopSpacingNonGlass;
 }
 
 void ToolbarView::LoadImages() {
   ThemeProvider* tp = GetThemeProvider();
 
   back_->SetImage(views::CustomButton::BS_NORMAL, tp->GetBitmapNamed(IDR_BACK));
   back_->SetImage(views::CustomButton::BS_HOT, tp->GetBitmapNamed(IDR_BACK_H));
@@ skipping 29 matching lines @@
   home_->SetImage(views::CustomButton::BS_NORMAL, tp->GetBitmapNamed(IDR_HOME));
   home_->SetImage(views::CustomButton::BS_HOT, tp->GetBitmapNamed(IDR_HOME_H));
   home_->SetImage(views::CustomButton::BS_PUSHED,
       tp->GetBitmapNamed(IDR_HOME_P));
 
   app_menu_->SetIcon(GetAppMenuIcon(views::CustomButton::BS_NORMAL));
   app_menu_->SetHoverIcon(GetAppMenuIcon(views::CustomButton::BS_HOT));
   app_menu_->SetPushedIcon(GetAppMenuIcon(views::CustomButton::BS_PUSHED));
 }
 
-void ToolbarView::ShowUpgradeReminder() {
-  update_reminder_animation_.reset(new SlideAnimation(this));
-  update_reminder_animation_->SetSlideDuration(kPulseDuration);
+void ToolbarView::ShowNotificationDot() {
+  notification_dot_animation_.reset(new SlideAnimation(this));
+  notification_dot_animation_->SetSlideDuration(kPulseDuration);
 
   // Then start the recurring timer for pulsating it.
-  upgrade_reminder_pulse_timer_.Start(
+  notification_dot_pulse_timer_.Stop();
+  notification_dot_pulse_timer_.Start(
       base::TimeDelta::FromMilliseconds(kPulsateEveryMs),
-      this, &ToolbarView::PulsateUpgradeNotifier);
+      this, &ToolbarView::PulsateNotificationDot);
 }
 
-void ToolbarView::PulsateUpgradeNotifier() {
+void ToolbarView::PulsateNotificationDot() {
   // Start the pulsating animation.
-  update_reminder_animation_->Reset(0.0);
-  update_reminder_animation_->Show();
+  notification_dot_animation_->Reset(0.0);
+  notification_dot_animation_->Show();
 }
 
 SkBitmap ToolbarView::GetAppMenuIcon(views::CustomButton::ButtonState state) {
   ThemeProvider* tp = GetThemeProvider();
 
   int id = 0;
   switch (state) {
     case views::CustomButton::BS_NORMAL: id = IDR_TOOLS;   break;
     case views::CustomButton::BS_HOT:    id = IDR_TOOLS_H; break;
     case views::CustomButton::BS_PUSHED: id = IDR_TOOLS_P; break;
     default:                             NOTREACHED();     break;
   }
   SkBitmap icon = *tp->GetBitmapNamed(id);
 
-  if (!IsUpgradeRecommended())
+  bool add_badge = IsUpgradeRecommended() || ShouldShowIncompatibilityWarning();
+  if (!add_badge)
     return icon;
 
   // Draw the chrome app menu icon onto the canvas.
   scoped_ptr<gfx::CanvasSkia> canvas(
       new gfx::CanvasSkia(icon.width(), icon.height(), false));
   canvas->DrawBitmapInt(icon, 0, 0);
 
   SkBitmap badge;
   static bool has_faded_in = false;
   if (!has_faded_in) {
-    SkBitmap* dot = tp->GetBitmapNamed(IDR_UPGRADE_DOT_INACTIVE);
+    SkBitmap* dot = NULL;
+    if (ShouldShowIncompatibilityWarning()) {
+#if defined(OS_WIN)
+      dot = tp->GetBitmapNamed(IDR_INCOMPATIBILITY_DOT_INACTIVE);
+#else
+      NOTREACHED();
+#endif
+    } else {
+      dot = tp->GetBitmapNamed(IDR_UPGRADE_DOT_INACTIVE);
+    }
     SkBitmap transparent;
     transparent.setConfig(dot->getConfig(), dot->width(), dot->height());
     transparent.allocPixels();
     transparent.eraseARGB(0, 0, 0, 0);
     badge = SkBitmapOperations::CreateBlendedBitmap(
-        *dot, transparent, 1.0 - update_reminder_animation_->GetCurrentValue());
-    if (update_reminder_animation_->GetCurrentValue() == 1.0)
+        *dot, transparent,
+        1.0 - notification_dot_animation_->GetCurrentValue());
+    if (notification_dot_animation_->GetCurrentValue() == 1.0)
       has_faded_in = true;
   } else {
     // Convert animation values that start from 0.0 and incrementally go
     // up to 1.0 into values that start in 0.0, go to 1.0 and then back
     // to 0.0 (to create a pulsing effect).
     double value =
-        1.0 - abs(2.0 * update_reminder_animation_->GetCurrentValue() - 1.0);
+        1.0 - abs(2.0 * notification_dot_animation_->GetCurrentValue() - 1.0);
 
     // Add the badge to it.
-    badge = SkBitmapOperations::CreateBlendedBitmap(
-        *tp->GetBitmapNamed(IDR_UPGRADE_DOT_INACTIVE),
-        *tp->GetBitmapNamed(IDR_UPGRADE_DOT_ACTIVE),
-        value);
+    if (ShouldShowIncompatibilityWarning()) {
+#if defined(OS_WIN)
+      badge = SkBitmapOperations::CreateBlendedBitmap(
+          *tp->GetBitmapNamed(IDR_INCOMPATIBILITY_DOT_INACTIVE),
+          *tp->GetBitmapNamed(IDR_INCOMPATIBILITY_DOT_ACTIVE),
+          value);
+#else
+      NOTREACHED();
+#endif
+    } else {
+      badge = SkBitmapOperations::CreateBlendedBitmap(
+          *tp->GetBitmapNamed(IDR_UPGRADE_DOT_INACTIVE),
+          *tp->GetBitmapNamed(IDR_UPGRADE_DOT_ACTIVE),
+          value);
+    }
   }
 
   static const int kBadgeLeftSpacing = 8;
   static const int kBadgeTopSpacing = 18;
   canvas->DrawBitmapInt(badge, kBadgeLeftSpacing, kBadgeTopSpacing);
 
   return canvas->ExtractBitmap();
 }