TabContentsWrapper -> TabContents, part 41.

chrome/browser/ui/gtk/collected_cookies_gtk.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 "chrome/browser/ui/gtk/collected_cookies_gtk.h"
 
 #include <string>
 #include "chrome/browser/browsing_data_appcache_helper.h"
 #include "chrome/browser/browsing_data_cookie_helper.h"
 #include "chrome/browser/browsing_data_database_helper.h"
 #include "chrome/browser/browsing_data_file_system_helper.h"
 #include "chrome/browser/browsing_data_indexed_db_helper.h"
 #include "chrome/browser/browsing_data_local_storage_helper.h"
 #include "chrome/browser/browsing_data_server_bound_cert_helper.h"
 #include "chrome/browser/content_settings/cookie_settings.h"
 #include "chrome/browser/content_settings/local_shared_objects_container.h"
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
 #include "chrome/browser/cookies_tree_model.h"
 #include "chrome/browser/infobars/infobar_tab_helper.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/collected_cookies_infobar_delegate.h"
 #include "chrome/browser/ui/browser_dialogs.h"
 #include "chrome/browser/ui/gtk/constrained_window_gtk.h"
 #include "chrome/browser/ui/gtk/gtk_chrome_cookie_view.h"
 #include "chrome/browser/ui/gtk/gtk_util.h"
-#include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
+#include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/notification_source.h"
 #include "grit/generated_resources.h"
 #include "ui/base/gtk/gtk_hig_constants.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace {
 // Width and height of the cookie tree view.
 const int kTreeViewWidth = 450;
@@ skipping 49 matching lines @@
       return std::string();
   }
 }
 
 }  // namespace
 
 namespace browser {
 
 // Declared in browser_dialogs.h so others don't have to depend on our header.
 void ShowCollectedCookiesDialog(gfx::NativeWindow parent_window,
-                                TabContentsWrapper* wrapper) {
+                                TabContents* tab_contents) {
   // Deletes itself on close.
-  new CollectedCookiesGtk(parent_window, wrapper);
+  new CollectedCookiesGtk(parent_window, tab_contents);
 }
 
 }  // namespace browser
 
 CollectedCookiesGtk::CollectedCookiesGtk(GtkWindow* parent,
-                                         TabContentsWrapper* wrapper)
-    : wrapper_(wrapper),
+                                         TabContents* tab_contents)
+    : tab_contents_(tab_contents),
       status_changed_(false) {
   registrar_.Add(this, chrome::NOTIFICATION_COLLECTED_COOKIES_SHOWN,
                  content::Source<TabSpecificContentSettings>(
-                     wrapper->content_settings()));
+                     tab_contents->content_settings()));
 
   Init();
 }
 
 void CollectedCookiesGtk::Init() {
   dialog_ = gtk_vbox_new(FALSE, ui::kContentAreaSpacing);
   gtk_box_set_spacing(GTK_BOX(dialog_), ui::kContentAreaSpacing);
 
   GtkWidget* label = gtk_label_new(
       l10n_util::GetStringUTF8(IDS_COLLECTED_COOKIES_DIALOG_TITLE).c_str());
@@ skipping 56 matching lines @@
   gtk_button_set_label(GTK_BUTTON(close_button_),
                        l10n_util::GetStringUTF8(IDS_CLOSE).c_str());
   g_signal_connect(close_button_, "clicked", G_CALLBACK(OnCloseThunk), this);
   gtk_box_pack_end(GTK_BOX(button_box), close_button_, FALSE, TRUE, 0);
 
   // Show the dialog.
   allowed_cookies_tree_adapter_->Init();
   blocked_cookies_tree_adapter_->Init();
   EnableControls();
   ShowCookieInfo(gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook_)));
-  window_ = new ConstrainedWindowGtk(wrapper_, this);
+  window_ = new ConstrainedWindowGtk(tab_contents_, this);
 }
 
 GtkWidget* CollectedCookiesGtk::CreateAllowedPane() {
   GtkWidget* cookie_list_vbox = gtk_vbox_new(FALSE, ui::kControlSpacing);
 
   GtkWidget* label = gtk_label_new(
       l10n_util::GetStringUTF8(IDS_COLLECTED_COOKIES_ALLOWED_COOKIES_LABEL).
           c_str());
   gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
   gtk_box_pack_start(GTK_BOX(cookie_list_vbox), label, FALSE, FALSE,
                      ui::kControlSpacing);
 
   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_box_pack_start(GTK_BOX(cookie_list_vbox), scroll_window, TRUE, TRUE, 0);
 
-  TabSpecificContentSettings* content_settings = wrapper_->content_settings();
+  TabSpecificContentSettings* content_settings =
+      tab_contents_->content_settings();
 
   const LocalSharedObjectsContainer& allowed_lsos =
       content_settings->allowed_local_shared_objects();
   allowed_cookies_tree_model_.reset(
       new CookiesTreeModel(allowed_lsos.cookies()->Clone(),
                            allowed_lsos.databases()->Clone(),
                            allowed_lsos.local_storages()->Clone(),
                            allowed_lsos.session_storages()->Clone(),
                            allowed_lsos.appcaches()->Clone(),
                            allowed_lsos.indexed_dbs()->Clone(),
@@ skipping 44 matching lines @@
 
   // Wrap the vbox inside an hbox so that we can specify padding along the
   // horizontal axis.
   GtkWidget* box = gtk_hbox_new(FALSE, 0);
   gtk_box_pack_start(GTK_BOX(box), cookie_list_vbox, TRUE, TRUE,
                      ui::kControlSpacing);
   return box;
 }
 
 GtkWidget* CollectedCookiesGtk::CreateBlockedPane() {
-  PrefService* prefs = wrapper_->profile()->GetPrefs();
+  PrefService* prefs = tab_contents_->profile()->GetPrefs();
 
   GtkWidget* cookie_list_vbox = gtk_vbox_new(FALSE, ui::kControlSpacing);
 
   GtkWidget* label = gtk_label_new(
       l10n_util::GetStringUTF8(
           prefs->GetBoolean(prefs::kBlockThirdPartyCookies) ?
               IDS_COLLECTED_COOKIES_BLOCKED_THIRD_PARTY_BLOCKING_ENABLED :
               IDS_COLLECTED_COOKIES_BLOCKED_COOKIES_LABEL).c_str());
   gtk_widget_set_size_request(label, kTreeViewWidth, -1);
   gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
   gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
   gtk_box_pack_start(GTK_BOX(cookie_list_vbox), label, TRUE, TRUE,
                      ui::kControlSpacing);
 
   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_box_pack_start(GTK_BOX(cookie_list_vbox), scroll_window, TRUE, TRUE, 0);
 
-  TabSpecificContentSettings* content_settings = wrapper_->content_settings();
+  TabSpecificContentSettings* content_settings =
+      tab_contents_->content_settings();
 
   const LocalSharedObjectsContainer& blocked_lsos =
       content_settings->blocked_local_shared_objects();
   blocked_cookies_tree_model_.reset(
       new CookiesTreeModel(blocked_lsos.cookies()->Clone(),
                            blocked_lsos.databases()->Clone(),
                            blocked_lsos.local_storages()->Clone(),
                            blocked_lsos.session_storages()->Clone(),
                            blocked_lsos.appcaches()->Clone(),
                            blocked_lsos.indexed_dbs()->Clone(),
@@ skipping 156 matching lines @@
 
 void CollectedCookiesGtk::Observe(int type,
                                   const content::NotificationSource& source,
                                   const content::NotificationDetails& details) {
   DCHECK(type == chrome::NOTIFICATION_COLLECTED_COOKIES_SHOWN);
   window_->CloseConstrainedWindow();
 }
 
 void CollectedCookiesGtk::OnClose(GtkWidget* close_button) {
   if (status_changed_) {
-    InfoBarTabHelper* infobar_helper = wrapper_->infobar_tab_helper();
+    InfoBarTabHelper* infobar_helper = tab_contents_->infobar_tab_helper();
     infobar_helper->AddInfoBar(
         new CollectedCookiesInfoBarDelegate(infobar_helper));
   }
   window_->CloseConstrainedWindow();
 }
 
 void CollectedCookiesGtk::AddExceptions(GtkTreeSelection* selection,
                                         gtk_tree::TreeAdapter* adapter,
                                         ContentSetting setting) {
   GtkTreeModel* model;
   GList* paths =
       gtk_tree_selection_get_selected_rows(selection, &model);
   string16 last_domain_name;
   bool multiple_domains_added = false;
   for (GList* item = paths; item; item = item->next) {
     GtkTreeIter iter;
     gtk_tree_model_get_iter(
         model, &iter, reinterpret_cast<GtkTreePath*>(item->data));
     CookieTreeNode* node =
         static_cast<CookieTreeNode*>(adapter->GetNode(&iter));
     if (node->GetDetailedInfo().node_type !=
         CookieTreeNode::DetailedInfo::TYPE_ORIGIN)
       continue;
     CookieTreeOriginNode* origin_node = static_cast<CookieTreeOriginNode*>(
         node);
     if (origin_node->CanCreateContentException()) {
       if (!last_domain_name.empty())
         multiple_domains_added = true;
       last_domain_name = origin_node->GetTitle();
-      Profile* profile = wrapper_->profile();
+      Profile* profile = tab_contents_->profile();
       origin_node->CreateContentException(
           CookieSettings::Factory::GetForProfile(profile), setting);
     }
   }
   g_list_foreach(paths, reinterpret_cast<GFunc>(gtk_tree_path_free), NULL);
   g_list_free(paths);
   if (last_domain_name.empty()) {
     gtk_widget_hide(infobar_);
   } else {
     gtk_label_set_text(
@@ skipping 34 matching lines @@
       tree_view, reinterpret_cast<gpointer>(OnTreeViewRowExpandedThunk), this);
   gtk_tree_view_expand_row(GTK_TREE_VIEW(tree_view), path, TRUE);
   g_signal_handlers_unblock_by_func(
       tree_view, reinterpret_cast<gpointer>(OnTreeViewRowExpandedThunk), this);
 }
 
 void CollectedCookiesGtk::OnTreeViewSelectionChange(GtkWidget* selection) {
   EnableControls();
   ShowCookieInfo(gtk_notebook_get_current_page(GTK_NOTEBOOK(notebook_)));
 }