content: Move collected cookies constrained window to TabContentsWrapper.

chrome/browser/ui/gtk/collected_cookies_gtk.cc

 // Copyright (c) 2011 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/content_settings/host_content_settings_map.h"
 #include "chrome/browser/content_settings/tab_specific_content_settings.h"
@@ skipping 59 matching lines @@
 
     case CONTENT_SETTING_SESSION_ONLY:
       return l10n_util::GetStringFUTF8(
           IDS_COLLECTED_COOKIES_SESSION_RULE_CREATED, domain_name);
 
     default:
       NOTREACHED();
       return std::string();
   }
 }
+
 }  // namespace
 
 CollectedCookiesGtk::CollectedCookiesGtk(GtkWindow* parent,
-                                         TabContents* tab_contents)
-    : tab_contents_(tab_contents),
+                                         TabContentsWrapper* wrapper)
+    : wrapper_(wrapper),
       status_changed_(false) {
-  TabSpecificContentSettings* content_settings =
-      TabContentsWrapper::GetCurrentWrapperForContents(tab_contents)->
-          content_settings();
   registrar_.Add(this, chrome::NOTIFICATION_COLLECTED_COOKIES_SHOWN,
-                 Source<TabSpecificContentSettings>(content_settings));
+                 Source<TabSpecificContentSettings>(
+                     wrapper->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(tab_contents_, this);
+  window_ = new ConstrainedWindowGtk(wrapper_->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 =
-      TabContentsWrapper::GetCurrentWrapperForContents(tab_contents_)->
-          content_settings();
+  TabSpecificContentSettings* content_settings = wrapper_->content_settings();
 
   allowed_cookies_tree_model_.reset(
       content_settings->GetAllowedCookiesTreeModel());
   allowed_cookies_tree_adapter_.reset(
       new gtk_tree::TreeAdapter(this, allowed_cookies_tree_model_.get()));
   allowed_tree_ = gtk_tree_view_new_with_model(
       GTK_TREE_MODEL(allowed_cookies_tree_adapter_->tree_store()));
   gtk_widget_set_size_request(allowed_tree_, kTreeViewWidth, kTreeViewHeight);
   gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(allowed_tree_), FALSE);
   gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(allowed_tree_), TRUE);
@@ skipping 33 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() {
-  TabContentsWrapper* wrapper =
-      TabContentsWrapper::GetCurrentWrapperForContents(tab_contents_);
   HostContentSettingsMap* host_content_settings_map =
-      wrapper->profile()->GetHostContentSettingsMap();
+      wrapper_->profile()->GetHostContentSettingsMap();
 
   GtkWidget* cookie_list_vbox = gtk_vbox_new(FALSE, ui::kControlSpacing);
 
   GtkWidget* label = gtk_label_new(
       l10n_util::GetStringUTF8(
           host_content_settings_map->BlockThirdPartyCookies() ?
               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 = wrapper_->content_settings();
 
   blocked_cookies_tree_model_.reset(
       content_settings->GetBlockedCookiesTreeModel());
   blocked_cookies_tree_adapter_.reset(
       new gtk_tree::TreeAdapter(this, blocked_cookies_tree_model_.get()));
   blocked_tree_ = gtk_tree_view_new_with_model(
       GTK_TREE_MODEL(blocked_cookies_tree_adapter_->tree_store()));
   gtk_widget_set_size_request(blocked_tree_, kTreeViewWidth, kTreeViewHeight);
   gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(blocked_tree_), FALSE);
   gtk_tree_view_set_enable_tree_lines(GTK_TREE_VIEW(blocked_tree_), TRUE);
@@ skipping 145 matching lines @@
 
 void CollectedCookiesGtk::Observe(int type,
                                   const NotificationSource& source,
                                   const NotificationDetails& details) {
   DCHECK(type == chrome::NOTIFICATION_COLLECTED_COOKIES_SHOWN);
   window_->CloseConstrainedWindow();
 }
 
 void CollectedCookiesGtk::OnClose(GtkWidget* close_button) {
   if (status_changed_) {
-    TabContentsWrapper::GetCurrentWrapperForContents(tab_contents_)->
-        infobar_tab_helper()->AddInfoBar(
-            new CollectedCookiesInfoBarDelegate(tab_contents_));
+    wrapper_->infobar_tab_helper()->AddInfoBar(
+        new CollectedCookiesInfoBarDelegate(wrapper_->tab_contents()));
   }
   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 =
-          Profile::FromBrowserContext(tab_contents_->browser_context());
+      Profile* profile = wrapper_->profile();
       origin_node->CreateContentException(
           profile->GetHostContentSettingsMap(), 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_)));
 }