Begin to upgrade BackForwardMenuModelViews to use new menu API....

chrome/browser/back_forward_menu_model.cc

 // Copyright (c) 2006-2009 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 "build/build_config.h"
 
 #include "chrome/browser/back_forward_menu_model.h"
 
 #include "app/l10n_util.h"
+#include "app/resource_bundle.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/tab_contents/navigation_controller.h"
 #include "chrome/browser/tab_contents/navigation_entry.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/url_constants.h"
 #include "grit/generated_resources.h"
+#include "grit/theme_resources.h"
 #include "net/base/registry_controlled_domain.h"
 
 const int BackForwardMenuModel::kMaxHistoryItems = 12;
 const int BackForwardMenuModel::kMaxChapterStops = 5;
 
+BackForwardMenuModel::BackForwardMenuModel(Browser* browser,
+                                           ModelType model_type)
+    : browser_(browser),
+      test_tab_contents_(NULL),
+      model_type_(model_type) {
+}
+
 int BackForwardMenuModel::GetHistoryItemCount() const {
   TabContents* contents = GetTabContents();
   int items = 0;
 
-  if (model_type_ == FORWARD_MENU_DELEGATE) {
+  if (model_type_ == FORWARD_MENU) {
     // Only count items from n+1 to end (if n is current entry)
     items = contents->controller().entry_count() -
             contents->controller().GetCurrentEntryIndex() - 1;
   } else {
     items = contents->controller().GetCurrentEntryIndex();
   }
 
   if (items > kMaxHistoryItems)
     items = kMaxHistoryItems;
   else if (items < 0)
     items = 0;
 
   return items;
 }
 
 int BackForwardMenuModel::GetChapterStopCount(int history_items) const {
   TabContents* contents = GetTabContents();
 
   int chapter_stops = 0;
   int current_entry = contents->controller().GetCurrentEntryIndex();
 
   if (history_items == kMaxHistoryItems) {
     int chapter_id = current_entry;
-    if (model_type_ == FORWARD_MENU_DELEGATE) {
+    if (model_type_ == FORWARD_MENU) {
       chapter_id += history_items;
     } else {
       chapter_id -= history_items;
     }
 
     do {
       chapter_id = GetIndexOfNextChapterStop(chapter_id,
-          model_type_ == FORWARD_MENU_DELEGATE);
+          model_type_ == FORWARD_MENU);
       if (chapter_id != -1)
         ++chapter_stops;
     } while (chapter_id != -1 && chapter_stops < kMaxChapterStops);
   }
 
   return chapter_stops;
 }
 
 int BackForwardMenuModel::GetTotalItemCount() const {
   int items = GetHistoryItemCount();
@@ skipping 137 matching lines @@
     return L"";
 
   NavigationEntry* entry = GetNavigationEntry(menu_id);
   return UTF16ToWideHack(entry->GetTitleForDisplay(
                          &GetTabContents()->controller()));
 }
 
 const SkBitmap& BackForwardMenuModel::GetItemIcon(int menu_id) const {
   DCHECK(ItemHasIcon(menu_id));
 
+  if (menu_id == GetTotalItemCount()) {
+    return *ResourceBundle::GetSharedInstance().GetBitmapNamed(
+        IDR_HISTORY_FAVICON);
+  }
+
   NavigationEntry* entry = GetNavigationEntry(menu_id);
   return entry->favicon().bitmap();
 }
 
 bool BackForwardMenuModel::ItemHasIcon(int menu_id) const {
-  // Using "id" not "id - 1" because the last item "Show Full History"
-  // doesn't have an icon.
-  return menu_id < GetTotalItemCount() && !IsSeparator(menu_id);
+  return menu_id - 1 < GetTotalItemCount() && !IsSeparator(menu_id);
 }
 
 bool BackForwardMenuModel::ItemHasCommand(int menu_id) const {
   return menu_id - 1 < GetTotalItemCount() && !IsSeparator(menu_id);
 }
 
 std::wstring BackForwardMenuModel::GetShowFullHistoryLabel() const {
   return l10n_util::GetString(IDS_SHOWFULLHISTORY_LINK);
 }
 
 TabContents* BackForwardMenuModel::GetTabContents() const {
   // We use the test tab contents if the unit test has specified it.
   return test_tab_contents_ ? test_tab_contents_ :
                               browser_->GetSelectedTabContents();
 }
 
 int BackForwardMenuModel::MenuIdToNavEntryIndex(int menu_id) const {
   TabContents* contents = GetTabContents();
   int history_items = GetHistoryItemCount();
 
   DCHECK(menu_id > 0);
 
   // Convert anything above the History items separator.
   if (menu_id <= history_items) {
-    if (model_type_ == FORWARD_MENU_DELEGATE) {
+    if (model_type_ == FORWARD_MENU) {
       // The |menu_id| is relative to our current position, so we need to add.
       menu_id += contents->controller().GetCurrentEntryIndex();
     } else {
       // Back menu is reverse.
       menu_id = contents->controller().GetCurrentEntryIndex() - menu_id;
     }
     return menu_id;
   }
   if (menu_id == history_items + 1)
     return -1;           // Don't translate the separator for history items.
 
   if (menu_id >= history_items + 1 + GetChapterStopCount(history_items) + 1)
     return -1;           // This is beyond the last chapter stop so we abort.
 
   // This menu item is a chapter stop located between the two separators.
   menu_id = FindChapterStop(history_items,
-                            model_type_ == FORWARD_MENU_DELEGATE,
+                            model_type_ == FORWARD_MENU,
                             menu_id - history_items - 1 - 1);
 
   return menu_id;
 }
 
 NavigationEntry* BackForwardMenuModel::GetNavigationEntry(int menu_id) const {
   int index = MenuIdToNavEntryIndex(menu_id);
   return GetTabContents()->controller().GetEntryAtIndex(index);
 }
 
 std::wstring BackForwardMenuModel::BuildActionName(
     const std::wstring& action, int index) const {
   DCHECK(!action.empty());
   DCHECK(index >= -1);
   std::wstring metric_string;
-  if (model_type_ == FORWARD_MENU_DELEGATE)
+  if (model_type_ == FORWARD_MENU)
     metric_string += L"ForwardMenu_";
   else
     metric_string += L"BackMenu_";
   metric_string += action;
   if (index != -1)
     metric_string += IntToWString(index);
   return metric_string;
 }