// 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 "chrome/browser/gtk/options/general_page_gtk.h"

#include "app/l10n_util.h"
#include "app/resource_bundle.h"
#include "base/gfx/gtk_util.h"
#include "base/gfx/png_decoder.h"
#include "chrome/browser/browser.h"
#include "chrome/browser/browser_list.h"
#include "chrome/browser/gtk/options/options_layout_gtk.h"
#include "chrome/browser/net/url_fixer_upper.h"
#include "chrome/browser/session_startup_pref.h"
#include "chrome/browser/shell_integration.h"
#include "chrome/common/gtk_util.h"
#include "chrome/common/pref_names.h"
#include "chrome/common/pref_service.h"
#include "chrome/common/url_constants.h"
#include "grit/app_resources.h"
#include "grit/chromium_strings.h"
#include "grit/generated_resources.h"

// TODO(mattm): spacing constants should be moved into a system-wide location
namespace {

// Spacing between options of the same group
const int kOptionSpacing = 6;

// Horizontal spacing between a label and its control
const int kLabelSpacing = 12;

// Markup for the text showing the current state of the default browser
const char kDefaultBrowserLabelMarkup[] = "<span color='#%s'>%s</span>";

// Color of the default browser text when Chromium is the default browser
const char kDefaultBrowserLabelColor[] = "008700";

// Color of the default browser text when Chromium is not the default browser
const char kNotDefaultBrowserLabelColor[] = "870000";

// Column ids for |startup_custom_pages_model_|.
enum {
  COL_FAVICON_HANDLE,
  COL_FAVICON,
  COL_URL,
  COL_COUNT,
};

}

///////////////////////////////////////////////////////////////////////////////
// GeneralPageGtk, public:

GeneralPageGtk::GeneralPageGtk(Profile* profile)
    : OptionsPageBase(profile),
      initializing_(true)  {
  OptionsLayoutBuilderGtk options_builder(4);
  options_builder.AddOptionGroup(
      l10n_util::GetStringUTF8(IDS_OPTIONS_STARTUP_GROUP_NAME),
      InitStartupGroup(), true);
  options_builder.AddOptionGroup(
      l10n_util::GetStringUTF8(IDS_OPTIONS_HOMEPAGE_GROUP_NAME),
      InitHomepageGroup(), false);
  options_builder.AddOptionGroup(
      l10n_util::GetStringUTF8(IDS_OPTIONS_DEFAULTSEARCH_GROUP_NAME),
      InitDefaultSearchGroup(), false);
  options_builder.AddOptionGroup(
      l10n_util::GetStringUTF8(IDS_OPTIONS_DEFAULTBROWSER_GROUP_NAME),
      InitDefaultBrowserGroup(), false);
  page_ = options_builder.get_page_widget();

  profile->GetPrefs()->AddPrefObserver(prefs::kRestoreOnStartup, this);
  profile->GetPrefs()->AddPrefObserver(prefs::kURLsToRestoreOnStartup, this);

  new_tab_page_is_home_page_.Init(prefs::kHomePageIsNewTabPage,
      profile->GetPrefs(), this);
  homepage_.Init(prefs::kHomePage, profile->GetPrefs(), this);
  show_home_button_.Init(prefs::kShowHomeButton, profile->GetPrefs(), this);

  // Load initial values
  NotifyPrefChanged(NULL);
}

GeneralPageGtk::~GeneralPageGtk() {
  profile()->GetPrefs()->RemovePrefObserver(prefs::kRestoreOnStartup, this);
  profile()->GetPrefs()->RemovePrefObserver(
      prefs::kURLsToRestoreOnStartup, this);
}

///////////////////////////////////////////////////////////////////////////////
// GeneralPageGtk, OptionsPageBase overrides:

void GeneralPageGtk::NotifyPrefChanged(const std::wstring* pref_name) {
  initializing_ = true;
  if (!pref_name || *pref_name == prefs::kRestoreOnStartup) {
    PrefService* prefs = profile()->GetPrefs();
    const SessionStartupPref startup_pref =
        SessionStartupPref::GetStartupPref(prefs);
    switch (startup_pref.type) {
    case SessionStartupPref::DEFAULT:
      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(startup_homepage_radio_),
                                   TRUE);
      EnableCustomHomepagesControls(false);
      break;

    case SessionStartupPref::LAST:
      gtk_toggle_button_set_active(
          GTK_TOGGLE_BUTTON(startup_last_session_radio_), TRUE);
      EnableCustomHomepagesControls(false);
      break;

    case SessionStartupPref::URLS:
      gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(startup_custom_radio_),
                                   TRUE);
      EnableCustomHomepagesControls(true);
      break;
    }
  }

  if (!pref_name || *pref_name == prefs::kURLsToRestoreOnStartup) {
    PrefService* prefs = profile()->GetPrefs();
    const SessionStartupPref startup_pref =
        SessionStartupPref::GetStartupPref(prefs);
    PopulateCustomUrlList(startup_pref.urls);
  }

  if (!pref_name || *pref_name == prefs::kHomePageIsNewTabPage) {
    if (new_tab_page_is_home_page_.GetValue()) {
      gtk_toggle_button_set_active(
          GTK_TOGGLE_BUTTON(homepage_use_newtab_radio_), TRUE);
      gtk_widget_set_sensitive(homepage_use_url_entry_, FALSE);
    } else {
      gtk_toggle_button_set_active(
          GTK_TOGGLE_BUTTON(homepage_use_url_radio_), TRUE);
      gtk_widget_set_sensitive(homepage_use_url_entry_, TRUE);
    }
  }

  if (!pref_name || *pref_name == prefs::kHomePage) {
    bool enabled = homepage_.GetValue() !=
        UTF8ToWide(chrome::kChromeUINewTabURL);
    if (enabled)
      gtk_entry_set_text(GTK_ENTRY(homepage_use_url_entry_),
                         WideToUTF8(homepage_.GetValue()).c_str());
  }

  if (!pref_name || *pref_name == prefs::kShowHomeButton) {
    gtk_toggle_button_set_active(
        GTK_TOGGLE_BUTTON(homepage_show_home_button_checkbox_),
        show_home_button_.GetValue());
  }
  initializing_ = false;
}

void GeneralPageGtk::HighlightGroup(OptionsGroup highlight_group) {
  // TODO(mattm): implement group highlighting
}

///////////////////////////////////////////////////////////////////////////////
// GeneralPageGtk, private:

GtkWidget* GeneralPageGtk::InitStartupGroup() {
  GtkWidget* vbox = gtk_vbox_new(FALSE, kOptionSpacing);

  startup_homepage_radio_ = gtk_radio_button_new_with_label(NULL,
      l10n_util::GetStringUTF8(
          IDS_OPTIONS_STARTUP_SHOW_DEFAULT_AND_NEWTAB).c_str());
  g_signal_connect(G_OBJECT(startup_homepage_radio_), "toggled",
                   G_CALLBACK(OnStartupRadioToggled), this);
  gtk_box_pack_start(GTK_BOX(vbox), startup_homepage_radio_, FALSE, FALSE, 0);

  startup_last_session_radio_ = gtk_radio_button_new_with_label_from_widget(
      GTK_RADIO_BUTTON(startup_homepage_radio_),
      l10n_util::GetStringUTF8(IDS_OPTIONS_STARTUP_SHOW_LAST_SESSION).c_str());
  g_signal_connect(G_OBJECT(startup_last_session_radio_), "toggled",
                   G_CALLBACK(OnStartupRadioToggled), this);
  gtk_box_pack_start(GTK_BOX(vbox), startup_last_session_radio_,
                     FALSE, FALSE, 0);

  startup_custom_radio_ = gtk_radio_button_new_with_label_from_widget(
      GTK_RADIO_BUTTON(startup_homepage_radio_),
      l10n_util::GetStringUTF8(IDS_OPTIONS_STARTUP_SHOW_PAGES).c_str());
  g_signal_connect(G_OBJECT(startup_custom_radio_), "toggled",
                   G_CALLBACK(OnStartupRadioToggled), this);
  gtk_box_pack_start(GTK_BOX(vbox), startup_custom_radio_, FALSE, FALSE, 0);

  GtkWidget* url_list_container = gtk_hbox_new(FALSE, kOptionSpacing);
  gtk_box_pack_start(GTK_BOX(vbox), url_list_container, TRUE, TRUE, 0);

  ResourceBundle& rb = ResourceBundle::GetSharedInstance();
  default_favicon_ = rb.GetPixbufNamed(IDR_DEFAULT_FAVICON);

  GtkWidget* scroll_window = gtk_scrolled_window_new(NULL, NULL);
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll_window),
                                 GTK_POLICY_AUTOMATIC,
                                 GTK_POLICY_AUTOMATIC);
  gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll_window),
                                      GTK_SHADOW_ETCHED_IN);
  gtk_container_add(GTK_CONTAINER(url_list_container),
                    scroll_window);
  startup_custom_pages_model_ = gtk_list_store_new(COL_COUNT,
                                                   G_TYPE_INT,
                                                   GDK_TYPE_PIXBUF,
                                                   G_TYPE_STRING);
  startup_custom_pages_tree_ = gtk_tree_view_new_with_model(
      GTK_TREE_MODEL(startup_custom_pages_model_));
  gtk_container_add(GTK_CONTAINER(scroll_window), startup_custom_pages_tree_);

  gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(startup_custom_pages_tree_),
                                    FALSE);
  GtkTreeViewColumn* column = gtk_tree_view_column_new();
  GtkCellRenderer* renderer = gtk_cell_renderer_pixbuf_new();
  gtk_tree_view_column_pack_start(column, renderer, FALSE);
  gtk_tree_view_column_add_attribute(column, renderer, "pixbuf", COL_FAVICON);
  renderer = gtk_cell_renderer_text_new();
  gtk_tree_view_column_pack_start(column, renderer, TRUE);
  gtk_tree_view_column_add_attribute(column, renderer, "text", COL_URL);
  gtk_tree_view_append_column(GTK_TREE_VIEW(startup_custom_pages_tree_),
                              column);
  startup_custom_pages_selection_ = gtk_tree_view_get_selection(
      GTK_TREE_VIEW(startup_custom_pages_tree_));
  gtk_tree_selection_set_mode(startup_custom_pages_selection_,
                              GTK_SELECTION_MULTIPLE);
  g_signal_connect(G_OBJECT(startup_custom_pages_selection_), "changed",
                   G_CALLBACK(OnStartupPagesSelectionChanged), this);

  GtkWidget* url_list_buttons = gtk_vbox_new(FALSE, kOptionSpacing);
  gtk_box_pack_end(GTK_BOX(url_list_container), url_list_buttons,
                   FALSE, FALSE, 0);

  startup_add_custom_page_button_ = gtk_button_new_with_mnemonic(
      gtk_util::ConvertAcceleratorsFromWindowsStyle(
          l10n_util::GetStringUTF8(IDS_OPTIONS_STARTUP_ADD_BUTTON)).c_str());
  g_signal_connect(G_OBJECT(startup_add_custom_page_button_), "clicked",
                   G_CALLBACK(OnStartupAddCustomPageClicked), this);
  gtk_box_pack_start(GTK_BOX(url_list_buttons), startup_add_custom_page_button_,
                     FALSE, FALSE, 0);
  startup_remove_custom_page_button_ = gtk_button_new_with_mnemonic(
      gtk_util::ConvertAcceleratorsFromWindowsStyle(
        l10n_util::GetStringUTF8(IDS_OPTIONS_STARTUP_REMOVE_BUTTON)).c_str());
  g_signal_connect(G_OBJECT(startup_remove_custom_page_button_), "clicked",
                   G_CALLBACK(OnStartupRemoveCustomPageClicked), this);
  gtk_box_pack_start(GTK_BOX(url_list_buttons),
                     startup_remove_custom_page_button_, FALSE, FALSE, 0);
  startup_use_current_page_button_ = gtk_button_new_with_mnemonic(
      gtk_util::ConvertAcceleratorsFromWindowsStyle(
          l10n_util::GetStringUTF8(IDS_OPTIONS_STARTUP_USE_CURRENT)).c_str());
  g_signal_connect(G_OBJECT(startup_use_current_page_button_), "clicked",
                   G_CALLBACK(OnStartupUseCurrentPageClicked), this);
  gtk_box_pack_start(GTK_BOX(url_list_buttons),
                     startup_use_current_page_button_, FALSE, FALSE, 0);

  return vbox;
}

GtkWidget* GeneralPageGtk::InitHomepageGroup() {
  GtkWidget* vbox = gtk_vbox_new(FALSE, kOptionSpacing);

  homepage_use_newtab_radio_ = gtk_radio_button_new_with_label(NULL,
      l10n_util::GetStringUTF8(IDS_OPTIONS_HOMEPAGE_USE_NEWTAB).c_str());
  g_signal_connect(G_OBJECT(homepage_use_newtab_radio_), "toggled",
                   G_CALLBACK(OnNewTabIsHomePageToggled), this);
  gtk_container_add(GTK_CONTAINER(vbox), homepage_use_newtab_radio_);

  GtkWidget* homepage_hbox = gtk_hbox_new(FALSE, kLabelSpacing);
  gtk_container_add(GTK_CONTAINER(vbox), homepage_hbox);

  homepage_use_url_radio_ = gtk_radio_button_new_with_label_from_widget(
      GTK_RADIO_BUTTON(homepage_use_newtab_radio_),
      l10n_util::GetStringUTF8(IDS_OPTIONS_HOMEPAGE_USE_URL).c_str());
  g_signal_connect(G_OBJECT(homepage_use_url_radio_), "toggled",
                   G_CALLBACK(OnNewTabIsHomePageToggled), this);
  gtk_box_pack_start(GTK_BOX(homepage_hbox), homepage_use_url_radio_,
                     FALSE, FALSE, 0);
  homepage_use_url_entry_ = gtk_entry_new();
  g_signal_connect(G_OBJECT(homepage_use_url_entry_), "changed",
                   G_CALLBACK(OnHomepageUseUrlEntryChanged), this);
  gtk_box_pack_start(GTK_BOX(homepage_hbox), homepage_use_url_entry_,
                     TRUE, TRUE, 0);

  homepage_show_home_button_checkbox_ = gtk_check_button_new_with_label(
      l10n_util::GetStringUTF8(IDS_OPTIONS_HOMEPAGE_SHOW_BUTTON).c_str());
  g_signal_connect(G_OBJECT(homepage_show_home_button_checkbox_), "toggled",
                   G_CALLBACK(OnShowHomeButtonToggled), this);
  gtk_container_add(GTK_CONTAINER(vbox), homepage_show_home_button_checkbox_);

  return vbox;
}

GtkWidget* GeneralPageGtk::InitDefaultSearchGroup() {
  GtkWidget* hbox = gtk_hbox_new(FALSE, kOptionSpacing);

  // TODO(mattm): hook these up
  default_search_engine_combobox_ = gtk_combo_box_new();
  gtk_container_add(GTK_CONTAINER(hbox), default_search_engine_combobox_);

  default_search_manage_engines_button_ = gtk_button_new_with_label(
      l10n_util::GetStringUTF8(
          IDS_OPTIONS_DEFAULTSEARCH_MANAGE_ENGINES_LINK).c_str());
  gtk_box_pack_end(GTK_BOX(hbox), default_search_manage_engines_button_,
                   FALSE, FALSE, 0);

  return hbox;
}

GtkWidget* GeneralPageGtk::InitDefaultBrowserGroup() {
  GtkWidget* vbox = gtk_vbox_new(FALSE, kOptionSpacing);

  default_browser_status_label_ = gtk_label_new(NULL);
  gtk_box_pack_start(GTK_BOX(vbox), default_browser_status_label_,
                     FALSE, FALSE, 0);

  default_browser_use_as_default_button_ = gtk_button_new_with_label(
      l10n_util::GetStringFUTF8(IDS_OPTIONS_DEFAULTBROWSER_USEASDEFAULT,
          l10n_util::GetStringUTF16(IDS_PRODUCT_NAME)).c_str());
  g_signal_connect(G_OBJECT(default_browser_use_as_default_button_), "clicked",
                   G_CALLBACK(OnBrowserUseAsDefaultClicked), this);
  gtk_box_pack_start(GTK_BOX(vbox), default_browser_use_as_default_button_,
                     FALSE, FALSE, 0);

  GtkWidget* vbox_alignment = gtk_alignment_new(0.0, 0.5, 0.0, 0.0);
  gtk_container_add(GTK_CONTAINER(vbox_alignment), vbox);

  SetDefaultBrowserUIState(ShellIntegration::IsDefaultBrowser());

  return vbox_alignment;
}

// static
void GeneralPageGtk::OnStartupRadioToggled(GtkToggleButton* toggle_button,
                                           GeneralPageGtk* general_page) {
  if (general_page->initializing_)
    return;
  if (!gtk_toggle_button_get_active(toggle_button)) {
    // When selecting a radio button, we get two signals (one for the old radio
    // being toggled off, one for the new one being toggled on.)  Ignore the
    // signal for toggling off the old button.
    return;
  }
  general_page->SaveStartupPref();
  GtkWidget* sender = GTK_WIDGET(toggle_button);
  if (sender == general_page->startup_homepage_radio_) {
    general_page->UserMetricsRecordAction(L"Options_Startup_Homepage",
                                          general_page->profile()->GetPrefs());
  } else if (sender == general_page->startup_last_session_radio_) {
    general_page->UserMetricsRecordAction(L"Options_Startup_LastSession",
                                          general_page->profile()->GetPrefs());
  } else if (sender == general_page->startup_custom_radio_) {
    general_page->UserMetricsRecordAction(L"Options_Startup_Custom",
                                          general_page->profile()->GetPrefs());
  }
}

// static
void GeneralPageGtk::OnStartupAddCustomPageClicked(
    GtkButton* button, GeneralPageGtk* general_page) {
  new UrlPickerDialogGtk(
      NewCallback(general_page, &GeneralPageGtk::OnAddCustomUrl),
      general_page->profile(),
      GTK_WINDOW(gtk_widget_get_toplevel(general_page->page_)));
}

// static
void GeneralPageGtk::OnStartupRemoveCustomPageClicked(
    GtkButton* button, GeneralPageGtk* general_page) {
  general_page->RemoveSelectedCustomUrls();
}

// static
void GeneralPageGtk::OnStartupUseCurrentPageClicked(
    GtkButton* button, GeneralPageGtk* general_page) {
  general_page->SetCustomUrlListFromCurrentPages();
}

// static
void GeneralPageGtk::OnStartupPagesSelectionChanged(
    GtkTreeSelection *selection, GeneralPageGtk* general_page) {
  general_page->EnableCustomHomepagesControls(true);
}

// static
void GeneralPageGtk::OnNewTabIsHomePageToggled(GtkToggleButton* toggle_button,
                                               GeneralPageGtk* general_page) {
  if (general_page->initializing_)
    return;
  if (!gtk_toggle_button_get_active(toggle_button)) {
    // Ignore the signal for toggling off the old button.
    return;
  }
  GtkWidget* sender = GTK_WIDGET(toggle_button);
  if (sender == general_page->homepage_use_newtab_radio_) {
    general_page->SetHomepage(GURL());
    general_page->UserMetricsRecordAction(L"Options_Homepage_UseNewTab",
                                          general_page->profile()->GetPrefs());
    gtk_widget_set_sensitive(general_page->homepage_use_url_entry_, FALSE);
  } else if (sender == general_page->homepage_use_url_radio_) {
    general_page->SetHomepageFromEntry();
    general_page->UserMetricsRecordAction(L"Options_Homepage_UseURL",
                                          general_page->profile()->GetPrefs());
    gtk_widget_set_sensitive(general_page->homepage_use_url_entry_, TRUE);
  }
}

// static
void GeneralPageGtk::OnHomepageUseUrlEntryChanged(
    GtkEditable* editable,
    GeneralPageGtk* general_page) {
  if (general_page->initializing_)
    return;
  general_page->SetHomepageFromEntry();
}

// static
void GeneralPageGtk::OnShowHomeButtonToggled(GtkToggleButton* toggle_button,
                                             GeneralPageGtk* general_page) {
  if (general_page->initializing_)
    return;
  bool enabled = gtk_toggle_button_get_active(toggle_button);
  general_page->show_home_button_.SetValue(enabled);
  if (enabled) {
    general_page->UserMetricsRecordAction(L"Options_Homepage_ShowHomeButton",
                                          general_page->profile()->GetPrefs());
  } else {
    general_page->UserMetricsRecordAction(L"Options_Homepage_HideHomeButton",
                                          general_page->profile()->GetPrefs());
  }
}

// static
void GeneralPageGtk::OnBrowserUseAsDefaultClicked(
    GtkButton* button,
    GeneralPageGtk* general_page) {
  general_page->SetDefaultBrowserUIState(
      ShellIntegration::SetAsDefaultBrowser());
  // If the user made Chrome the default browser, then he/she arguably wants
  // to be notified when that changes.
  general_page->profile()->GetPrefs()->SetBoolean(prefs::kCheckDefaultBrowser,
                                                  true);
  general_page->UserMetricsRecordAction(L"Options_SetAsDefaultBrowser",
                                        general_page->profile()->GetPrefs());
}

void GeneralPageGtk::SaveStartupPref() {
  SessionStartupPref pref;

  if (gtk_toggle_button_get_active(
      GTK_TOGGLE_BUTTON(startup_last_session_radio_))) {
    pref.type = SessionStartupPref::LAST;
  } else if (gtk_toggle_button_get_active(
      GTK_TOGGLE_BUTTON(startup_custom_radio_))) {
    pref.type = SessionStartupPref::URLS;
  }

  pref.urls = GetCustomUrlList();

  SessionStartupPref::SetStartupPref(profile()->GetPrefs(), pref);
}

void GeneralPageGtk::PopulateCustomUrlList(const std::vector<GURL>& urls) {
  gtk_list_store_clear(startup_custom_pages_model_);
  for (size_t i = 0; i < urls.size(); ++i) {
    GtkTreeIter iter;
    gtk_list_store_append(startup_custom_pages_model_, &iter);
    PopulateCustomUrlRow(urls[i], &iter);
  }
}

void GeneralPageGtk::PopulateCustomUrlRow(const GURL& url, GtkTreeIter* iter) {
  HistoryService* history =
      profile()->GetHistoryService(Profile::EXPLICIT_ACCESS);
  HistoryService::Handle handle(0);
  if (history) {
    handle = history->GetFavIconForURL(
        url, &fav_icon_consumer_,
        NewCallback(this, &GeneralPageGtk::OnGotFavIcon));
  }
  gtk_list_store_set(startup_custom_pages_model_, iter,
                     COL_FAVICON_HANDLE, handle,
                     COL_FAVICON, default_favicon_,
                     COL_URL, url.spec().c_str(),
                     -1);
}

bool GeneralPageGtk::GetRowByFavIconHandle(HistoryService::Handle handle,
                                           GtkTreeIter* result_iter) {
  GtkTreeIter iter;
  gboolean valid = gtk_tree_model_get_iter_first(
      GTK_TREE_MODEL(startup_custom_pages_model_), &iter);
  while (valid) {
    gint row_handle;
    gtk_tree_model_get(GTK_TREE_MODEL(startup_custom_pages_model_), &iter,
                       COL_FAVICON_HANDLE, &row_handle,
                       -1);
    if (row_handle == handle) {
      *result_iter = iter;
      return true;
    }
    valid = gtk_tree_model_iter_next(
        GTK_TREE_MODEL(startup_custom_pages_model_), &iter);
  }
  return false;
}

void GeneralPageGtk::OnGotFavIcon(HistoryService::Handle handle,
                                  bool know_fav_icon,
                                  scoped_refptr<RefCountedBytes> image_data,
                                  bool is_expired,
                                  GURL icon_url) {
  GtkTreeIter iter;
  if (!GetRowByFavIconHandle(handle, &iter))
    return;
  gtk_list_store_set(startup_custom_pages_model_, &iter,
                     COL_FAVICON_HANDLE, 0,
                     -1);
  if (know_fav_icon && image_data.get() && !image_data->data.empty()) {
    int width, height;
    std::vector<unsigned char> decoded_data;
    if (PNGDecoder::Decode(&image_data->data.front(), image_data->data.size(),
                           PNGDecoder::FORMAT_BGRA, &decoded_data, &width,
                           &height)) {
      SkBitmap icon;
      icon.setConfig(SkBitmap::kARGB_8888_Config, width, height);
      icon.allocPixels();
      memcpy(icon.getPixels(), &decoded_data.front(),
             width * height * 4);
      GdkPixbuf* pixbuf = gfx::GdkPixbufFromSkBitmap(&icon);
      gtk_list_store_set(startup_custom_pages_model_, &iter,
                         COL_FAVICON, pixbuf,
                         -1);
      g_object_unref(pixbuf);
    }
  }
}

void GeneralPageGtk::SetCustomUrlListFromCurrentPages() {
  std::vector<GURL> urls;
  for (BrowserList::const_iterator browser_i = BrowserList::begin();
       browser_i != BrowserList::end(); ++browser_i) {
    Browser* browser = *browser_i;
    if (browser->profile() != profile())
      continue;  // Only want entries for open profile.

    for (int tab_index = 0; tab_index < browser->tab_count(); ++tab_index) {
      TabContents* tab = browser->GetTabContentsAt(tab_index);
      if (tab->ShouldDisplayURL()) {
        const GURL url = browser->GetTabContentsAt(tab_index)->GetURL();
        if (!url.is_empty())
          urls.push_back(url);
      }
    }
  }
  PopulateCustomUrlList(urls);
  SaveStartupPref();
}

void GeneralPageGtk::OnAddCustomUrl(const GURL& url) {
  GtkTreeIter iter;
  if (gtk_tree_selection_count_selected_rows(
      startup_custom_pages_selection_) == 1) {
    GList* list = gtk_tree_selection_get_selected_rows(
        startup_custom_pages_selection_, NULL);
    GtkTreeIter sibling;
    gtk_tree_model_get_iter(GTK_TREE_MODEL(startup_custom_pages_model_),
                            &sibling, static_cast<GtkTreePath*>(list->data));
    g_list_foreach(list, (GFunc)gtk_tree_path_free, NULL);
    g_list_free(list);

    gtk_list_store_insert_before(startup_custom_pages_model_,
                                 &iter, &sibling);
  } else {
    gtk_list_store_append(startup_custom_pages_model_, &iter);
  }
  PopulateCustomUrlRow(url, &iter);
  SaveStartupPref();
}

void GeneralPageGtk::RemoveSelectedCustomUrls() {
  GList* list = gtk_tree_selection_get_selected_rows(
      startup_custom_pages_selection_, NULL);
  std::vector<GtkTreeIter> selected_iters(
      gtk_tree_selection_count_selected_rows(startup_custom_pages_selection_));
  GList* node;
  size_t i;
  for (i = 0, node = list; node != NULL; ++i, node = node->next) {
    gtk_tree_model_get_iter(GTK_TREE_MODEL(startup_custom_pages_model_),
                            &selected_iters[i],
                            static_cast<GtkTreePath*>(node->data));
  }
  g_list_foreach(list, (GFunc)gtk_tree_path_free, NULL);
  g_list_free(list);

  for (i = 0; i < selected_iters.size(); ++i) {
    gtk_list_store_remove(startup_custom_pages_model_, &selected_iters[i]);
  }
  SaveStartupPref();
}

std::vector<GURL> GeneralPageGtk::GetCustomUrlList() const {
  std::vector<GURL> urls;
  GtkTreeIter iter;
  gboolean valid = gtk_tree_model_get_iter_first(
      GTK_TREE_MODEL(startup_custom_pages_model_), &iter);
  while (valid) {
    gchar* url_data;
    gtk_tree_model_get(GTK_TREE_MODEL(startup_custom_pages_model_), &iter,
                       COL_URL, &url_data,
                       -1);
    urls.push_back(GURL(url_data));
    g_free(url_data);
    valid = gtk_tree_model_iter_next(
        GTK_TREE_MODEL(startup_custom_pages_model_), &iter);
  }
  return urls;
}

void GeneralPageGtk::SetHomepage(const GURL& homepage) {
  if (!homepage.is_valid() || homepage.spec() == chrome::kChromeUINewTabURL) {
    new_tab_page_is_home_page_.SetValue(true);
  } else {
    new_tab_page_is_home_page_.SetValue(false);
    homepage_.SetValue(UTF8ToWide(homepage.spec()));
  }
}

void GeneralPageGtk::SetHomepageFromEntry() {
  GURL url(URLFixerUpper::FixupURL(
      gtk_entry_get_text(GTK_ENTRY(homepage_use_url_entry_)), ""));
  SetHomepage(url);
}

void GeneralPageGtk::EnableCustomHomepagesControls(bool enable) {
  gtk_widget_set_sensitive(startup_add_custom_page_button_, enable);
  gtk_widget_set_sensitive(startup_remove_custom_page_button_,
      enable &&
      gtk_tree_selection_count_selected_rows(startup_custom_pages_selection_));
  gtk_widget_set_sensitive(startup_use_current_page_button_, enable);
  gtk_widget_set_sensitive(startup_custom_pages_tree_, enable);
}

void GeneralPageGtk::SetDefaultBrowserUIState(bool is_default) {
  const char* color;
  std::string text;
  if (is_default) {
    color = kDefaultBrowserLabelColor;
    text = l10n_util::GetStringFUTF8(IDS_OPTIONS_DEFAULTBROWSER_DEFAULT,
        l10n_util::GetStringUTF16(IDS_PRODUCT_NAME));
  } else {
    color = kNotDefaultBrowserLabelColor;
    text = l10n_util::GetStringFUTF8(IDS_OPTIONS_DEFAULTBROWSER_NOTDEFAULT,
        l10n_util::GetStringUTF16(IDS_PRODUCT_NAME));
  }
  char* markup = g_markup_printf_escaped(kDefaultBrowserLabelMarkup,
                                         color, text.c_str());
  gtk_label_set_markup(GTK_LABEL(default_browser_status_label_), markup);
  g_free(markup);

  gtk_widget_set_sensitive(default_browser_use_as_default_button_, !is_default);
}