Notificaitons refactor step 2

ui/message_center/message_view.cc

 // Copyright (c) 2012 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 "ui/message_center/message_view.h"
 
 #include "grit/ui_resources.h"
 #include "grit/ui_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/models/simple_menu_model.h"
@@ skipping 126 matching lines @@
 // Menu constants
 const int kTogglePermissionCommand = 0;
 const int kToggleExtensionCommand = 1;
 const int kShowSettingsCommand = 2;
 
 // A dropdown menu for notifications.
 class WebNotificationMenuModel : public ui::SimpleMenuModel,
                                  public ui::SimpleMenuModel::Delegate {
  public:
   WebNotificationMenuModel(NotificationList::Delegate* list_delegate,
-                           const Notification& notification)
+                           const std::string& notification_id,
+                           const string16& display_source,
+                           const std::string& extension_id)
       : ALLOW_THIS_IN_INITIALIZER_LIST(ui::SimpleMenuModel(this)),
         list_delegate_(list_delegate),
-        notification_(notification) {
+        notification_id_(notification_id),
+        display_source_(display_source) {
     // Add 'disable notifications' menu item.
-    if (!notification.extension_id.empty()) {
+    if (!extension_id.empty()) {
       AddItem(kToggleExtensionCommand,
               GetLabelForCommandId(kToggleExtensionCommand));
-    } else if (!notification.display_source.empty()) {
+    } else if (!display_source.empty()) {
       AddItem(kTogglePermissionCommand,
               GetLabelForCommandId(kTogglePermissionCommand));
     }
     // Add settings menu item.
-    if (!notification.display_source.empty()) {
+    if (!display_source.empty()) {
       AddItem(kShowSettingsCommand,
               GetLabelForCommandId(kShowSettingsCommand));
     }
   }
 
   virtual ~WebNotificationMenuModel() {
   }
 
   // Overridden from ui::SimpleMenuModel:
   virtual string16 GetLabelForCommandId(int command_id) const OVERRIDE {
     switch (command_id) {
       case kToggleExtensionCommand:
         return l10n_util::GetStringUTF16(IDS_MESSAGE_CENTER_EXTENSIONS_DISABLE);
       case kTogglePermissionCommand:
         return l10n_util::GetStringFUTF16(IDS_MESSAGE_CENTER_SITE_DISABLE,
-                                          notification_.display_source);
+                                          display_source_);
       case kShowSettingsCommand:
         return l10n_util::GetStringUTF16(IDS_MESSAGE_CENTER_SETTINGS);
       default:
         NOTREACHED();
     }
     return string16();
   }
 
   // Overridden from ui::SimpleMenuModel::Delegate:
   virtual bool IsCommandIdChecked(int command_id) const OVERRIDE {
     return false;
   }
 
   virtual bool IsCommandIdEnabled(int command_id) const OVERRIDE {
     return false;
   }
 
   virtual bool GetAcceleratorForCommandId(
       int command_id,
       ui::Accelerator* accelerator) OVERRIDE {
     return false;
   }
 
   virtual void ExecuteCommand(int command_id) OVERRIDE {
     switch (command_id) {
       case kToggleExtensionCommand:
-        list_delegate_->DisableNotificationByExtension(notification_.id);
+        list_delegate_->DisableNotificationByExtension(notification_id_);
         break;
       case kTogglePermissionCommand:
-        list_delegate_->DisableNotificationByUrl(notification_.id);
+        list_delegate_->DisableNotificationByUrl(notification_id_);
         break;
       case kShowSettingsCommand:
-        list_delegate_->ShowNotificationSettings(notification_.id);
+        list_delegate_->ShowNotificationSettings(notification_id_);
         break;
       default:
         NOTREACHED();
     }
   }
 
  private:
-  NotificationList::Delegate* list_delegate_;
-  Notification notification_;
+  NotificationList::Delegate* list_delegate_; // Weak, global MessageCenter
+  std::string notification_id_;
+  string16 display_source_;
 
   DISALLOW_COPY_AND_ASSIGN(WebNotificationMenuModel);
 };
 
-MessageView::MessageView(
-    NotificationList::Delegate* list_delegate,
-    const Notification& notification)
+MessageView::MessageView(NotificationList::Delegate* list_delegate,
+                         const Notification& notification)
     : list_delegate_(list_delegate),
-      notification_(notification),
+      notification_id_(notification.id()),
+      display_source_(notification.display_source()),
+      extension_id_(notification.extension_id()),
       scroller_(NULL) {
   ControlButton *close = new ControlButton(this);
   close->SetPadding(-kCloseIconRightPadding, kCloseIconTopPadding);
   close->SetNormalImage(IDR_NOTIFICATION_CLOSE);
   close->SetHoveredImage(IDR_NOTIFICATION_CLOSE_HOVER);
   close->SetPressedImage(IDR_NOTIFICATION_CLOSE_PRESSED);
   close_button_.reset(close);
 }
 
 MessageView::MessageView() {
 }
 
 MessageView::~MessageView() {
 }
 
 bool MessageView::OnMousePressed(const ui::MouseEvent& event) {
   if (event.flags() & ui::EF_RIGHT_MOUSE_BUTTON) {
     ShowMenu(event.location());
     return true;
   }
-  list_delegate_->OnNotificationClicked(notification_.id);
+  list_delegate_->OnNotificationClicked(notification_id_);
   return true;
 }
 
 void MessageView::OnGestureEvent(ui::GestureEvent* event) {
   if (event->type() == ui::ET_GESTURE_TAP) {
-    list_delegate_->OnNotificationClicked(notification_.id);
+    list_delegate_->OnNotificationClicked(notification_id_);
     event->SetHandled();
     return;
   }
 
   if (event->type() == ui::ET_GESTURE_LONG_PRESS) {
     ShowMenu(event->location());
     event->SetHandled();
     return;
   }
 
   SlideOutView::OnGestureEvent(event);
   // Do not return here by checking handled(). SlideOutView calls SetHandled()
   // even though the scroll gesture doesn't make no (or little) effects on the
   // slide-out behavior. See http://crbug.com/172991
 
   if (!event->IsScrollGestureEvent())
     return;
 
   if (scroller_)
     scroller_->OnGestureEvent(event);
   event->SetHandled();
 }
 
 void MessageView::ButtonPressed(views::Button* sender,
                                 const ui::Event& event) {
   if (sender == close_button())
-    list_delegate_->SendRemoveNotification(notification_.id);
+    list_delegate_->SendRemoveNotification(notification_id_);
 }
 
 void MessageView::ShowMenu(gfx::Point screen_location) {
-  WebNotificationMenuModel menu_model(list_delegate_, notification_);
+  WebNotificationMenuModel menu_model(list_delegate_,
+                                      notification_id_,
+                                      display_source_,
+                                      extension_id_);
   if (menu_model.GetItemCount() == 0)
     return;
 
   views::MenuModelAdapter menu_model_adapter(&menu_model);
   views::MenuRunner menu_runner(menu_model_adapter.CreateMenu());
 
   views::View::ConvertPointToScreen(this, &screen_location);
   ignore_result(menu_runner.RunMenuAt(
       GetWidget()->GetTopLevelWidget(),
       NULL,
       gfx::Rect(screen_location, gfx::Size()),
       views::MenuItemView::TOPRIGHT,
       views::MenuRunner::HAS_MNEMONICS));
 }
 
 void MessageView::OnSlideOut() {
-  list_delegate_->SendRemoveNotification(notification_.id);
+  list_delegate_->SendRemoveNotification(notification_id_);
 }
 
 }  // namespace message_center