Move blocked content from TabContents to TabContentsWrapper.

content/browser/tab_contents/tab_contents.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 "content/browser/tab_contents/tab_contents.h"
 
 #include <cmath>
 
-#include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/stats_counters.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
-#include "chrome/browser/blocked_content_container.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/character_encoding.h"
 #include "chrome/browser/content_settings/content_settings_details.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/debugger/devtools_manager.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/dom_operation_notification_details.h"
 #include "chrome/browser/download/download_item_model.h"
 #include "chrome/browser/download/download_manager.h"
@@ skipping 204 matching lines @@
       bookmark_drag_(NULL),
       is_loading_(false),
       crashed_status_(base::TERMINATION_STATUS_STILL_RUNNING),
       crashed_error_code_(0),
       waiting_for_response_(false),
       max_page_id_(-1),
       load_state_(net::LOAD_STATE_IDLE),
       upload_size_(0),
       upload_position_(0),
       received_page_title_(false),
-      blocked_contents_(NULL),
-      all_contents_blocked_(false),
       displayed_insecure_content_(false),
       capturing_contents_(false),
       is_being_destroyed_(false),
       notify_disconnection_(false),
 #if defined(OS_WIN)
       message_box_active_(CreateEvent(NULL, TRUE, FALSE, NULL)),
 #endif
       suppress_javascript_messages_(false),
       is_showing_before_unload_dialog_(false),
       opener_web_ui_type_(WebUI::kNoWebUI),
@@ skipping 70 matching lines @@
 
   NotifyDisconnected();
   browser::HideHungRendererDialog(this);
 
   // First cleanly close all child windows.
   // TODO(mpcomplete): handle case if MaybeCloseChildWindows() already asked
   // some of these to close.  CloseWindows is async, so it might get called
   // twice before it runs.
   CloseConstrainedWindows();
 
-  // Close all blocked contents.
-  if (blocked_contents_)
-    blocked_contents_->Destroy();
-
   // Notify any observer that have a reference on this tab contents.
   NotificationService::current()->Notify(
       NotificationType::TAB_CONTENTS_DESTROYED,
       Source<TabContents>(this),
       NotificationService::NoDetails());
 
   // Notify any lasting InfobarDelegates that have not yet been removed that
   // whatever infobar they were handling in this TabContents has closed,
   // because the TabContents is going away entirely.
   // This must happen after the TAB_CONTENTS_DESTROYED notification as the
@@ skipping 456 matching lines @@
   SkColor greyish = SkColorSetARGB(178, 0, 0, 0);
   if (rwhv)
     rwhv->SetVisuallyDeemphasized(blocked ? &greyish : NULL, false);
   // RenderViewHost may be NULL during shutdown.
   if (render_view_host())
     render_view_host()->set_ignore_input_events(blocked);
   if (delegate_)
     delegate_->SetTabContentBlocked(this, blocked);
 }
 
-
-void TabContents::AddOrBlockNewContents(TabContents* new_contents,
-                                        WindowOpenDisposition disposition,
-                                        const gfx::Rect& initial_pos,
-                                        bool user_gesture) {
-  if (all_contents_blocked_) {
-    if (!blocked_contents_)
-      blocked_contents_ = new BlockedContentContainer(this);
-    blocked_contents_->AddTabContents(
-        new_contents, disposition, initial_pos, user_gesture);
-    return;
-  }
-
+void TabContents::AddNewContents(TabContents* new_contents,
+                                 WindowOpenDisposition disposition,
+                                 const gfx::Rect& initial_pos,
+                                 bool user_gesture) {
   if (!delegate_)
     return;
 
-  if ((disposition == NEW_POPUP) && !user_gesture &&
-      !CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kDisablePopupBlocking)) {
-    // Unrequested popups from normal pages are constrained unless they're in
-    // the whitelist.  The popup owner will handle checking this.
-    delegate_->GetConstrainingContents(this)->AddPopup(
-        new_contents, initial_pos, user_gesture);
-  } else {
-    AddNewContents(new_contents, disposition, initial_pos, user_gesture);
-  }
-
-  // TODO(pkasting): Why is this necessary?
-  PopupNotificationVisibilityChanged(blocked_contents_ != NULL);
-}
-
-void TabContents::PopupNotificationVisibilityChanged(bool visible) {
-  if (is_being_destroyed_)
-    return;
-  content_settings_delegate_->SetPopupsBlocked(visible);
+  delegate_->AddNewContents(this, new_contents, disposition, initial_pos,
+                            user_gesture);
 }
 
 gfx::NativeView TabContents::GetContentNativeView() const {
   return view_->GetContentNativeView();
 }
 
 gfx::NativeView TabContents::GetNativeView() const {
   return view_->GetNativeView();
 }
 
@@ skipping 165 matching lines @@
     child_windows_.erase(i);
   if (child_windows_.empty()) {
     BlockTabContent(false);
   } else {
     if (removed_topmost_window)
       child_windows_[0]->ShowConstrainedWindow();
     BlockTabContent(true);
   }
 }
 
-void TabContents::WillCloseBlockedContentContainer(
-    BlockedContentContainer* container) {
-  DCHECK(blocked_contents_ == container);
-  blocked_contents_ = NULL;
-  PopupNotificationVisibilityChanged(false);
-}
-
 void TabContents::EmailPageLocation() {
   std::string title = EscapeQueryParamValue(UTF16ToUTF8(GetTitle()), false);
   std::string page_url = EscapeQueryParamValue(GetURL().spec(), false);
   std::string mailto = std::string("mailto:?subject=Fwd:%20") +
       title + "&body=%0A%0A" + page_url;
   platform_util::OpenExternal(GURL(mailto));
 }
 
 bool TabContents::IsActiveEntry(int32 page_id) {
   NavigationEntry* active_entry = controller_.GetActiveEntry();
   return (active_entry != NULL &&
           active_entry->site_instance() == GetSiteInstance() &&
           active_entry->page_id() == page_id);
 }
 
 void TabContents::SetOverrideEncoding(const std::string& encoding) {
   set_encoding(encoding);
   render_view_host()->SetPageEncoding(encoding);
 }
 
 void TabContents::ResetOverrideEncoding() {
   reset_encoding();
   render_view_host()->ResetPageEncodingToDefault();
 }
 
 void TabContents::WindowMoveOrResizeStarted() {
   render_view_host()->WindowMoveOrResizeStarted();
 }
 
-void TabContents::SetAllContentsBlocked(bool value) {
-  if (all_contents_blocked_ == value)
-    return;
-
-  all_contents_blocked_ = value;
-  if (!all_contents_blocked_ && blocked_contents_) {
-    std::vector<TabContents*> blocked;
-    blocked_contents_->GetBlockedContents(&blocked);
-    for (size_t i = 0; i < blocked.size(); ++i)
-      blocked_contents_->LaunchForContents(blocked[i]);
-  }
-}
-
 void TabContents::LogNewTabTime(const std::string& event_name) {
   // Not all new tab pages get timed.  In those cases, we don't have a
   // new_tab_start_time_.
   if (new_tab_start_time_.is_null())
     return;
 
   base::TimeDelta duration = base::TimeTicks::Now() - new_tab_start_time_;
   MetricEventDurationDetails details(event_name,
       static_cast<int>(duration.InMilliseconds()));
 
@@ skipping 300 matching lines @@
   NotificationType type = is_loading ? NotificationType::LOAD_START :
       NotificationType::LOAD_STOP;
   NotificationDetails det = NotificationService::NoDetails();
   if (details)
       det = Details<LoadNotificationDetails>(details);
   NotificationService::current()->Notify(type,
       Source<NavigationController>(&controller_),
       det);
 }
 
-void TabContents::AddNewContents(TabContents* new_contents,
-                                 WindowOpenDisposition disposition,
-                                 const gfx::Rect& initial_pos,
-                                 bool user_gesture) {
-    new_contents->DisassociateFromPopupCount();
-    delegate_->AddNewContents(this, new_contents, disposition, initial_pos,
-                              user_gesture);
-    NotificationService::current()->Notify(
-        NotificationType::TAB_ADDED,
-        Source<TabContentsDelegate>(delegate_),
-        Details<TabContents>(this));
-}
-
-void TabContents::AddPopup(TabContents* new_contents,
-                           const gfx::Rect& initial_pos,
-                           bool user_gesture) {
-  // A page can't spawn popups (or do anything else, either) until its load
-  // commits, so when we reach here, the popup was spawned by the
-  // NavigationController's last committed entry, not the active entry.  For
-  // example, if a page opens a popup in an onunload() handler, then the active
-  // entry is the page to be loaded as we navigate away from the unloading
-  // page.  For this reason, we can't use GetURL() to get the opener URL,
-  // because it returns the active entry.
-  NavigationEntry* entry = controller_.GetLastCommittedEntry();
-  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, user_gesture);
-  } else {
-    if (!blocked_contents_)
-      blocked_contents_ = new BlockedContentContainer(this);
-    // Call blocked_contents_->AddTabContents with user_gesture == true
-    // so that the contents will not get blocked again.
-    // TODO(stevenjb): Remove user_gesture parameter from
-    // BlockedContentContainer::AddTabContents()?
-    blocked_contents_->AddTabContents(new_contents,
-                                      NEW_POPUP,
-                                      initial_pos,
-                                      true);  // user gesture
-    content_settings_delegate_->OnContentBlocked(CONTENT_SETTINGS_TYPE_POPUPS,
-                                                 std::string());
-  }
-}
-
 void TabContents::ExpireInfoBars(
     const NavigationController::LoadCommittedDetails& details) {
   // Only hide InfoBars when the user has done something that makes the main
   // frame load. We don't want various automatic or subframe navigations making
   // it disappear.
   if (!details.is_user_initiated_main_frame_load())
     return;
 
   // NOTE: It is not safe to change the following code to count upwards or use
   // iterators, as the RemoveInfoBar() call synchronously modifies our delegate
@@ skipping 83 matching lines @@
 
   // Get the favicon, either from history or request it from the net.
   favicon_helper_->FetchFavicon(details.entry->url());
 
   if (touch_icon_helper_.get())
     touch_icon_helper_->FetchFavicon(details.entry->url());
 
   // Clear all page actions, blocked content notifications and browser actions
   // for this tab, unless this is an in-page navigation.
   if (!details.is_in_page) {
-    // Close blocked popups.
-    if (blocked_contents_) {
-      blocked_contents_->Destroy();
-      blocked_contents_ = NULL;
-    }
-
     // Clear "blocked" flags.
     content_settings_delegate_->ClearBlockedContentSettingsExceptForCookies();
     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.
@@ skipping 976 matching lines @@
 
 void TabContents::CreateViewAndSetSizeForRVH(RenderViewHost* rvh) {
   RenderWidgetHostView* rwh_view = view()->CreateViewForWidget(rvh);
   rwh_view->SetSize(view()->GetContainerSize());
 }
 
 void TabContents::OnOnlineStateChanged(bool online) {
   render_view_host()->Send(new ViewMsg_NetworkStateChanged(
       render_view_host()->routing_id(), online));
 }