Change InfoBar-related notifications to be sourced from a TabContentsWrapper, not a TabContents. ...

chrome/browser/ui/gtk/infobars/infobar_container_gtk.cc

 // Copyright (c) 2011 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/gtk/infobars/infobar_container_gtk.h"
 
 #include <gtk/gtk.h>
 
 #include <utility>
 
@@ skipping 78 matching lines @@
 void InfoBarContainerGtk::ChangeTabContents(TabContentsWrapper* contents) {
   if (tab_contents_)
     registrar_.RemoveAll();
 
   gtk_util::RemoveAllChildren(widget());
   UpdateToolbarInfoBarState(NULL, false);
 
   tab_contents_ = contents;
   if (tab_contents_) {
     UpdateInfoBars();
-    Source<TabContents> source(tab_contents_->tab_contents());
+    Source<TabContentsWrapper> source(tab_contents_);
     registrar_.Add(this, NotificationType::TAB_CONTENTS_INFOBAR_ADDED, source);
     registrar_.Add(this, NotificationType::TAB_CONTENTS_INFOBAR_REMOVED,
                    source);
     registrar_.Add(this, NotificationType::TAB_CONTENTS_INFOBAR_REPLACED,
                    source);
   }
 }
 
 void InfoBarContainerGtk::RemoveDelegate(InfoBarDelegate* delegate) {
   tab_contents_->RemoveInfoBar(delegate);
 }
 
 int InfoBarContainerGtk::TotalHeightOfAnimatingBars() const {
   int sum = 0;
   gtk_container_foreach(GTK_CONTAINER(widget()), SumAnimatingBarHeight, &sum);
   return sum;
 }
 
 // InfoBarContainerGtk, NotificationObserver implementation: -------------------
 
 void InfoBarContainerGtk::Observe(NotificationType type,
                                   const NotificationSource& source,
                                   const NotificationDetails& details) {
-  if (type == NotificationType::TAB_CONTENTS_INFOBAR_ADDED) {
-    AddInfoBar(Details<InfoBarDelegate>(details).ptr(), true);
-  } else if (type == NotificationType::TAB_CONTENTS_INFOBAR_REMOVED) {
-    RemoveInfoBar(Details<InfoBarDelegate>(details).ptr(), true);
-  } else if (type == NotificationType::TAB_CONTENTS_INFOBAR_REPLACED) {
-    std::pair<InfoBarDelegate*, InfoBarDelegate*>* delegates =
-        Details<std::pair<InfoBarDelegate*, InfoBarDelegate*> >(details).ptr();
+  switch (type.value) {
+    case NotificationType::TAB_CONTENTS_INFOBAR_ADDED:
+      AddInfoBar(Details<InfoBar>(details).ptr(), true);
+      break;
 
-    // By not animating the removal/addition, this appears to be a replace.
-    RemoveInfoBar(delegates->first, false);
-    AddInfoBar(delegates->second, false);
-  } else {
-    NOTREACHED();
+    case NotificationType::TAB_CONTENTS_INFOBAR_REMOVED: {
+      typedef std::pair<InfoBarDelegate*, bool> RemoveDetails;
+      RemoveDetails* remove_details = Details<RemoveDetails>(details).ptr();
+      RemoveInfoBar(remove_details->first, remove_details->second);
+      break;
+    }
+
+    case NotificationType::TAB_CONTENTS_INFOBAR_REPLACED: {
+      typedef std::pair<InfoBarDelegate*, InfoBar*> ReplaceDetails;
+      ReplaceDetails* replace_details = Details<ReplaceDetails>(details).ptr();
+      RemoveInfoBar(replace_details->first, false);
+      AddInfoBar(replace_details->second, false);
+      break;
+    }
+
+    default:
+      NOTREACHED();
+      break;
   }
 }
 
 // InfoBarContainerGtk, private: -----------------------------------------------
 
 void InfoBarContainerGtk::UpdateInfoBars() {
   for (size_t i = 0; i < tab_contents_->infobar_count(); ++i) {
     InfoBarDelegate* delegate = tab_contents_->GetInfoBarDelegateAt(i);
-    AddInfoBar(delegate, false);
+    AddInfoBar(delegate->CreateInfoBar(tab_contents_), false);
   }
 }
 
 void InfoBarContainerGtk::ShowArrowForDelegate(InfoBarDelegate* delegate,
                                                bool animate) {
   GList* children = gtk_container_get_children(GTK_CONTAINER(widget()));
   if (!children)
     return;
 
   // Iterate through the infobars and find the last one that isn't closing.
@@ skipping 13 matching lines @@
   }
 
   if (last_bar)
     last_bar->ShowArrowFor(this_bar, animate);
   else
     UpdateToolbarInfoBarState(this_bar, animate);
 
   g_list_free(children);
 }
 
-void InfoBarContainerGtk::AddInfoBar(InfoBarDelegate* delegate, bool animate) {
-  InfoBar* infobar = delegate->CreateInfoBar(tab_contents_);
+void InfoBarContainerGtk::AddInfoBar(InfoBar* infobar, bool animate) {
   infobar->set_container(this);
   infobar->SetThemeProvider(GtkThemeService::GetFrom(profile_));
   gtk_box_pack_start(GTK_BOX(widget()), infobar->widget(),
                      FALSE, FALSE, 0);
 
   infobar->Show(animate);
-  ShowArrowForDelegate(delegate, animate);
+  ShowArrowForDelegate(infobar->delegate(), animate);
 }
 
 void InfoBarContainerGtk::RemoveInfoBar(InfoBarDelegate* delegate,
                                         bool animate) {
   if (animate) {
     gtk_container_foreach(GTK_CONTAINER(widget()),
                           AnimateClosingForDelegate, delegate);
   } else {
     gtk_container_foreach(GTK_CONTAINER(widget()), ClosingForDelegate,
                           delegate);
@@ skipping 11 matching lines @@
 }
 
 void InfoBarContainerGtk::UpdateToolbarInfoBarState(InfoBar* infobar,
                                                     bool animate) {
   GtkWindow* parent = platform_util::GetTopLevel(widget());
   BrowserWindowGtk* browser_window =
       BrowserWindowGtk::GetBrowserWindowForNativeWindow(parent);
   if (browser_window)
     browser_window->SetInfoBarShowing(infobar, animate);
 }