Store blocked cookies in the tab contents.

chrome/browser/tab_contents/tab_contents.cc

 // Copyright (c) 2010 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/tab_contents/tab_contents.h"
 
 #if defined(OS_CHROMEOS)
 // For GdkScreen
 #include <gdk/gdk.h>
 #endif  // defined(OS_CHROMEOS)
@@ skipping 276 matching lines @@
       history_requests_(),
 #if defined(OS_WIN)
       message_box_active_(CreateEvent(NULL, TRUE, FALSE, NULL)),
 #endif
       last_javascript_message_dismissal_(),
       suppress_javascript_messages_(false),
       is_showing_before_unload_dialog_(false),
       renderer_preferences_(),
       opener_dom_ui_type_(DOMUIFactory::kNoDOMUI),
       language_state_(&controller_),
-      geolocation_settings_state_(profile),
       closed_by_user_gesture_(false) {
-  ClearBlockedContentSettings();
   renderer_preferences_util::UpdateFromSystemSettings(
       &renderer_preferences_, profile);
 
+  content_settings_delegate_.reset(
+      new TabSpecificContentSettings(this, profile));
+
 #if defined(OS_CHROMEOS)
   // Make sure the thumbnailer is started before starting the render manager.
   // The thumbnailer will want to listen for RVH creations, one of which will
   // happen in RVHManager::Init.
   ThumbnailGenerator* generator = g_browser_process->GetThumbnailGenerator();
   if (generator)
     generator->StartThumbnailing();
 #endif
 
   render_manager_.Init(profile, site_instance, routing_id);
@@ skipping 329 matching lines @@
   // Always display a throbber during pending loads.
   if (controller_.GetLastCommittedEntry() && controller_.pending_entry())
     return true;
 
   DOMUI* dom_ui = GetDOMUIForCurrentState();
   if (dom_ui)
     return !dom_ui->hide_favicon();
   return true;
 }
 
-bool TabContents::IsContentBlocked(ContentSettingsType content_type) const {
-  DCHECK(content_type != CONTENT_SETTINGS_TYPE_GEOLOCATION)
-      << "Geolocation settings handled by ContentSettingGeolocationImageModel";
-  DCHECK(content_type != CONTENT_SETTINGS_TYPE_NOTIFICATIONS)
-      << "Notifications settings handled by "
-      << "ContentSettingsNotificationsImageModel";
-
-  if (content_type == CONTENT_SETTINGS_TYPE_POPUPS)
-    return blocked_popups_ != NULL;
-
-  if (content_type == CONTENT_SETTINGS_TYPE_IMAGES ||
-      content_type == CONTENT_SETTINGS_TYPE_JAVASCRIPT ||
-      content_type == CONTENT_SETTINGS_TYPE_PLUGINS ||
-      content_type == CONTENT_SETTINGS_TYPE_COOKIES)
-    return content_blocked_[content_type];
-
-  NOTREACHED();
-  return false;
-}
-
 std::wstring TabContents::GetStatusText() const {
   if (!is_loading() || load_state_ == net::LOAD_STATE_IDLE)
     return std::wstring();
 
   switch (load_state_) {
     case net::LOAD_STATE_WAITING_FOR_CACHE:
       return l10n_util::GetString(IDS_LOAD_STATE_WAITING_FOR_CACHE);
     case net::LOAD_STATE_ESTABLISHING_PROXY_TUNNEL:
       return l10n_util::GetString(IDS_LOAD_STATE_ESTABLISHING_PROXY_TUNNEL);
     case net::LOAD_STATE_RESOLVING_PROXY_FOR_URL:
@@ skipping 268 matching lines @@
     return false;
 
   return host->Send(new ViewMsg_ExecuteCode(host->routing_id(),
       ViewMsg_ExecuteCode_Params(request_id, extension_id, host_permissions,
                                  is_js_code, code_string, all_frames)));
 }
 
 void TabContents::PopupNotificationVisibilityChanged(bool visible) {
   if (is_being_destroyed_)
     return;
+  content_settings_delegate_->SetPopupsBlocked(visible);
   if (!dont_notify_render_view_)
     render_view_host()->AllowScriptToClose(!visible);
-  if (delegate_)
-    delegate_->OnContentSettingsChange(this);
 }
 
 gfx::NativeView TabContents::GetContentNativeView() const {
   return view_->GetContentNativeView();
 }
 
 gfx::NativeView TabContents::GetNativeView() const {
   return view_->GetNativeView();
 }
 
@@ skipping 413 matching lines @@
       new TabContents(profile(), NULL, MSG_ROUTING_NONE, NULL);
   new_contents->SetExtensionApp(extension_app_);
   new_contents->controller().RestoreFromState(navigations, 0, false);
 
   if (!extension_app_ && entry)
     new_contents->controller().GetActiveEntry()->favicon() = entry->favicon();
 
   return new_contents;
 }
 
-// Resets the |content_blocked_| array.
-void TabContents::ClearBlockedContentSettings() {
-  for (size_t i = 0; i < arraysize(content_blocked_); ++i)
-    content_blocked_[i] = false;
-}
-
 // Notifies the RenderWidgetHost instance about the fact that the page is
 // loading, or done loading and calls the base implementation.
 void TabContents::SetIsLoading(bool is_loading,
                                LoadNotificationDetails* details) {
   if (is_loading == is_loading_)
     return;
 
   if (!is_loading) {
     load_state_ = net::LOAD_STATE_IDLE;
     load_state_host_.clear();
@@ skipping 33 matching lines @@
   GURL creator = entry ? entry->virtual_url() : GURL::EmptyGURL();
 
   if (creator.is_valid() &&
       profile()->GetHostContentSettingsMap()->GetContentSetting(
           creator, CONTENT_SETTINGS_TYPE_POPUPS) == CONTENT_SETTING_ALLOW) {
     AddNewContents(new_contents, NEW_POPUP, initial_pos, true);
   } else {
     if (!blocked_popups_)
       blocked_popups_ = new BlockedPopupContainer(this);
     blocked_popups_->AddTabContents(new_contents, initial_pos);
+    content_settings_delegate_->OnContentBlocked(CONTENT_SETTINGS_TYPE_POPUPS);
   }
 }
 
 namespace {
 bool TransitionIsReload(PageTransition::Type transition) {
   return PageTransition::StripQualifier(transition) == PageTransition::RELOAD;
 }
 }
 
 void TabContents::ExpireInfoBars(
@@ skipping 122 matching lines @@
     }
 
     // Close blocked popups.
     if (blocked_popups_) {
       AutoReset<bool> auto_reset(&dont_notify_render_view_, true);
       blocked_popups_->Destroy();
       blocked_popups_ = NULL;
     }
 
     // Clear "blocked" flags.
-    ClearBlockedContentSettings();
-    geolocation_settings_state_.DidNavigate(details);
-    if (delegate_)
-      delegate_->OnContentSettingsChange(this);
+    content_settings_delegate_->ClearBlockedContentSettings();
+    content_settings_delegate_->GeolocationDidNavigate(details);
 
     // Once the main frame is navigated, we're no longer considered to have
     // displayed insecure content.
     displayed_insecure_content_ = false;
   }
 
   // Close constrained windows if necessary.
   if (!net::RegistryControlledDomainService::SameDomainOrHost(
       details.previous_url, details.entry->url()))
     CloseConstrainedWindows();
@@ skipping 519 matching lines @@
   NotificationService::current()->Notify(
       NotificationType::FAIL_PROVISIONAL_LOAD_WITH_ERROR,
       Source<NavigationController>(&controller_),
       Details<ProvisionalLoadDetails>(&details));
 }
 
 void TabContents::DocumentLoadedInFrame() {
   controller_.DocumentLoadedInFrame();
 }
 
-void TabContents::OnContentBlocked(ContentSettingsType type) {
-  DCHECK(type != CONTENT_SETTINGS_TYPE_GEOLOCATION)
-      << "Geolocation settings handled by OnGeolocationPermissionSet";
-  content_blocked_[type] = true;
+void TabContents::OnContentSettingsChange() {
   if (delegate_)
     delegate_->OnContentSettingsChange(this);
 }
-
-void TabContents::OnGeolocationPermissionSet(const GURL& requesting_origin,
-                                             bool allowed) {
-  geolocation_settings_state_.OnGeolocationPermissionSet(requesting_origin,
-                                                         allowed);
-  if (delegate_)
-    delegate_->OnContentSettingsChange(this);
-}
 
 RenderViewHostDelegate::View* TabContents::GetViewDelegate() {
   return view_.get();
 }
 
 RenderViewHostDelegate::RendererManagement*
 TabContents::GetRendererManagementDelegate() {
   return &render_manager_;
 }
 
 RenderViewHostDelegate::BrowserIntegration*
     TabContents::GetBrowserIntegrationDelegate() {
   return this;
 }
 
 RenderViewHostDelegate::Resource* TabContents::GetResourceDelegate() {
   return this;
 }
 
 RenderViewHostDelegate::ContentSettings*
 TabContents::GetContentSettingsDelegate() {
-  return this;
+  return content_settings_delegate_.get();
 }
 
 RenderViewHostDelegate::Save* TabContents::GetSaveDelegate() {
   return save_package_.get();  // May be NULL, but we can return NULL.
 }
 
 RenderViewHostDelegate::Printing* TabContents::GetPrintingDelegate() {
   return &printing_;
 }
 
@@ skipping 18 matching lines @@
 
 RenderViewHostDelegate::BookmarkDrag* TabContents::GetBookmarkDragDelegate() {
   return bookmark_drag_;
 }
 
 void TabContents::SetBookmarkDragDelegate(
     RenderViewHostDelegate::BookmarkDrag* bookmark_drag) {
   bookmark_drag_ = bookmark_drag;
 }
 
+TabSpecificContentSettings* TabContents::GetTabSpecificContentSettings() const {
+  return content_settings_delegate_.get();
+}
+
 RendererPreferences TabContents::GetRendererPrefs(Profile* profile) const {
   return renderer_preferences_;
 }
 
 TabContents* TabContents::GetAsTabContents() {
   return this;
 }
 
 ViewType::Type TabContents::GetRenderViewType() const {
   return ViewType::TAB_CONTENTS;
@@ skipping 955 matching lines @@
   AddInfoBar(new SavePasswordInfoBarDelegate(this, form_to_save));
 }
 
 Profile* TabContents::GetProfileForPasswordManager() {
   return profile();
 }
 
 bool TabContents::DidLastPageLoadEncounterSSLErrors() {
   return controller().ssl_manager()->ProcessedSSLErrorFromRequest();
 }