chrome/browser/custom_home_pages_table_model.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/custom_home_pages_table_model.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/i18n/rtl.h"
  10 #include "base/prefs/pref_service.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "chrome/browser/history/history_service.h"
  13 #include "chrome/browser/history/history_service_factory.h"
  14 #include "chrome/browser/profiles/profile.h"
  15 #include "chrome/browser/ui/browser.h"
  16 #include "chrome/browser/ui/browser_iterator.h"
  17 #include "chrome/browser/ui/browser_list.h"
  18 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  19 #include "chrome/common/pref_names.h"
  20 #include "chrome/common/url_constants.h"
  21 #include "chrome/grit/generated_resources.h"
  22 #include "content/public/browser/web_contents.h"
  23 #include "net/base/net_util.h"
  24 #include "ui/base/l10n/l10n_util.h"
  25 #include "ui/base/models/table_model_observer.h"
  26 #include "ui/gfx/codec/png_codec.h"
  27 #include "url/gurl.h"
  28
  29 namespace {
  30
  31 // Checks whether the given URL should count as one of the "current" pages.
  32 // Returns true for all pages except dev tools and settings.
  33 bool ShouldAddPage(const GURL& url) {
  34   if (url.is_empty())
  35     return false;
  36
  37   if (url.SchemeIs(content::kChromeDevToolsScheme))
  38     return false;
  39
  40   if (url.SchemeIs(content::kChromeUIScheme)) {
  41     if (url.host() == chrome::kChromeUISettingsHost)
  42       return false;
  43
  44     // For a settings page, the path will start with "/settings" not "settings"
  45     // so find() will return 1, not 0.
  46     if (url.host() == chrome::kChromeUIUberHost &&
  47         url.path().find(chrome::kChromeUISettingsHost) == 1) {
  48       return false;
  49     }
  50   }
  51
  52   return true;
  53 }
  54
  55 }  // namespace
  56
  57 struct CustomHomePagesTableModel::Entry {
  58   Entry() : task_id(base::CancelableTaskTracker::kBadTaskId) {}
  59
  60   // URL of the page.
  61   GURL url;
  62
  63   // Page title.  If this is empty, we'll display the URL as the entry.
  64   base::string16 title;
  65
  66   // If not |base::CancelableTaskTracker::kBadTaskId|, indicates we're loading
  67   // the title for the page.
  68   base::CancelableTaskTracker::TaskId task_id;
  69 };
  70
  71 CustomHomePagesTableModel::CustomHomePagesTableModel(Profile* profile)
  72     : profile_(profile),
  73       observer_(NULL) {
  74 }
  75
  76 CustomHomePagesTableModel::~CustomHomePagesTableModel() {
  77 }
  78
  79 void CustomHomePagesTableModel::SetURLs(const std::vector<GURL>& urls) {
  80   entries_.resize(urls.size());
  81   for (size_t i = 0; i < urls.size(); ++i) {
  82     entries_[i].url = urls[i];
  83     entries_[i].title.erase();
  84     LoadTitle(&(entries_[i]));
  85   }
  86   // Complete change, so tell the view to just rebuild itself.
  87   if (observer_)
  88     observer_->OnModelChanged();
  89 }
  90
  91 /**
  92  * Move a number of existing entries to a new position, reordering the table.
  93  *
  94  * We determine the range of elements affected by the move, save the moved
  95  * elements, compact the remaining ones, and re-insert moved elements.
  96  * Expects |index_list| to be ordered ascending.
  97  */
  98 void CustomHomePagesTableModel::MoveURLs(int insert_before,
  99                                          const std::vector<int>& index_list) {
 100   if (index_list.empty()) return;
 101   DCHECK(insert_before >= 0 && insert_before <= RowCount());
 102
 103   // The range of elements that needs to be reshuffled is [ |first|, |last| ).
 104   int first = std::min(insert_before, index_list.front());
 105   int last = std::max(insert_before, index_list.back() + 1);
 106
 107   // Save the dragged elements. Also, adjust insertion point if it is before a
 108   // dragged element.
 109   std::vector<Entry> moved_entries;
 110   for (size_t i = 0; i < index_list.size(); ++i) {
 111     moved_entries.push_back(entries_[index_list[i]]);
 112     if (index_list[i] == insert_before)
 113       insert_before++;
 114   }
 115
 116   // Compact the range between beginning and insertion point, moving downwards.
 117   size_t skip_count = 0;
 118   for (int i = first; i < insert_before; ++i) {
 119     if (skip_count < index_list.size() && index_list[skip_count] == i)
 120       skip_count++;
 121     else
 122       entries_[i - skip_count] = entries_[i];
 123   }
 124
 125   // Moving items down created a gap. We start compacting up after it.
 126   first = insert_before;
 127   insert_before -= skip_count;
 128
 129   // Now compact up for elements after the insertion point.
 130   skip_count = 0;
 131   for (int i = last - 1; i >= first; --i) {
 132     if (skip_count < index_list.size() &&
 133         index_list[index_list.size() - skip_count - 1] == i) {
 134       skip_count++;
 135     } else {
 136       entries_[i + skip_count] = entries_[i];
 137     }
 138   }
 139
 140   // Insert moved elements.
 141   std::copy(moved_entries.begin(), moved_entries.end(),
 142       entries_.begin() + insert_before);
 143
 144   // Possibly large change, so tell the view to just rebuild itself.
 145   if (observer_)
 146     observer_->OnModelChanged();
 147 }
 148
 149 void CustomHomePagesTableModel::Add(int index, const GURL& url) {
 150   DCHECK(index >= 0 && index <= RowCount());
 151   entries_.insert(entries_.begin() + static_cast<size_t>(index), Entry());
 152   entries_[index].url = url;
 153   LoadTitle(&(entries_[index]));
 154   if (observer_)
 155     observer_->OnItemsAdded(index, 1);
 156 }
 157
 158 void CustomHomePagesTableModel::Remove(int index) {
 159   DCHECK(index >= 0 && index < RowCount());
 160   Entry* entry = &(entries_[index]);
 161   // Cancel any pending load requests now so we don't deref a bogus pointer when
 162   // we get the loaded notification.
 163   if (entry->task_id != base::CancelableTaskTracker::kBadTaskId) {
 164     task_tracker_.TryCancel(entry->task_id);
 165     entry->task_id = base::CancelableTaskTracker::kBadTaskId;
 166   }
 167   entries_.erase(entries_.begin() + static_cast<size_t>(index));
 168   if (observer_)
 169     observer_->OnItemsRemoved(index, 1);
 170 }
 171
 172 void CustomHomePagesTableModel::SetToCurrentlyOpenPages() {
 173   // Remove the current entries.
 174   while (RowCount())
 175     Remove(0);
 176
 177   // And add all tabs for all open browsers with our profile.
 178   int add_index = 0;
 179   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
 180     Browser* browser = *it;
 181     if (browser->profile() != profile_)
 182       continue;  // Skip incognito browsers.
 183
 184     for (int tab_index = 0;
 185          tab_index < browser->tab_strip_model()->count();
 186          ++tab_index) {
 187       const GURL url =
 188           browser->tab_strip_model()->GetWebContentsAt(tab_index)->GetURL();
 189       if (ShouldAddPage(url))
 190         Add(add_index++, url);
 191     }
 192   }
 193 }
 194
 195 std::vector<GURL> CustomHomePagesTableModel::GetURLs() {
 196   std::vector<GURL> urls(entries_.size());
 197   for (size_t i = 0; i < entries_.size(); ++i)
 198     urls[i] = entries_[i].url;
 199   return urls;
 200 }
 201
 202 int CustomHomePagesTableModel::RowCount() {
 203   return static_cast<int>(entries_.size());
 204 }
 205
 206 base::string16 CustomHomePagesTableModel::GetText(int row, int column_id) {
 207   DCHECK(column_id == 0);
 208   DCHECK(row >= 0 && row < RowCount());
 209   return entries_[row].title.empty() ? FormattedURL(row) : entries_[row].title;
 210 }
 211
 212 base::string16 CustomHomePagesTableModel::GetTooltip(int row) {
 213   return entries_[row].title.empty() ? base::string16() :
 214       l10n_util::GetStringFUTF16(IDS_OPTIONS_STARTUP_PAGE_TOOLTIP,
 215                                  entries_[row].title, FormattedURL(row));
 216 }
 217
 218 void CustomHomePagesTableModel::SetObserver(ui::TableModelObserver* observer) {
 219   observer_ = observer;
 220 }
 221
 222 void CustomHomePagesTableModel::LoadTitle(Entry* entry) {
 223     HistoryService* history_service = HistoryServiceFactory::GetForProfile(
 224         profile_, Profile::EXPLICIT_ACCESS);
 225   if (history_service) {
 226     entry->task_id = history_service->QueryURL(
 227         entry->url,
 228         false,
 229         base::Bind(&CustomHomePagesTableModel::OnGotTitle,
 230                    base::Unretained(this),
 231                    entry->url),
 232         &task_tracker_);
 233   }
 234 }
 235
 236 void CustomHomePagesTableModel::OnGotTitle(const GURL& entry_url,
 237                                            bool found_url,
 238                                            const history::URLRow& row,
 239                                            const history::VisitVector& visits) {
 240   Entry* entry = NULL;
 241   size_t entry_index = 0;
 242   for (size_t i = 0; i < entries_.size(); ++i) {
 243     if (entries_[i].url == entry_url) {
 244       entry = &entries_[i];
 245       entry_index = i;
 246       break;
 247     }
 248   }
 249   if (!entry) {
 250     // The URLs changed before we were called back.
 251     return;
 252   }
 253   entry->task_id = base::CancelableTaskTracker::kBadTaskId;
 254   if (found_url && !row.title().empty()) {
 255     entry->title = row.title();
 256     if (observer_)
 257       observer_->OnItemsChanged(static_cast<int>(entry_index), 1);
 258   }
 259 }
 260
 261 base::string16 CustomHomePagesTableModel::FormattedURL(int row) const {
 262   std::string languages =
 263       profile_->GetPrefs()->GetString(prefs::kAcceptLanguages);
 264   base::string16 url = net::FormatUrl(entries_[row].url, languages);
 265   url = base::i18n::GetDisplayStringInLTRDirectionality(url);
 266   return url;
 267 }