Move blocked content from TabContents to TabContentsWrapper.

chrome/browser/ui/blocked_content/blocked_content_container.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/blocked_content_container.h"
+#include "chrome/browser/ui/blocked_content/blocked_content_container.h"
 
+#include "chrome/browser/ui/blocked_content/blocked_content_tab_helper.h"
+#include "chrome/browser/ui/tab_contents/tab_contents_wrapper.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "ui/gfx/rect.h"
 
 // static
 const size_t BlockedContentContainer::kImpossibleNumberOfPopups = 30;
 
 struct BlockedContentContainer::BlockedContent {
-  BlockedContent(TabContents* tab_contents,
+  BlockedContent(TabContentsWrapper* tab_contents,
                  WindowOpenDisposition disposition,
                  const gfx::Rect& bounds,
                  bool user_gesture)
       : tab_contents(tab_contents),
         disposition(disposition),
         bounds(bounds),
         user_gesture(user_gesture) {
   }
 
-  TabContents* tab_contents;
+  TabContentsWrapper* tab_contents;
   WindowOpenDisposition disposition;
   gfx::Rect bounds;
   bool user_gesture;
 };
 
-BlockedContentContainer::BlockedContentContainer(TabContents* owner)
+BlockedContentContainer::BlockedContentContainer(TabContentsWrapper* owner)
     : owner_(owner) {
 }
 
-BlockedContentContainer::~BlockedContentContainer() {}
+BlockedContentContainer::~BlockedContentContainer() {
+  Clear();
+}
 
-void BlockedContentContainer::AddTabContents(TabContents* tab_contents,
+void BlockedContentContainer::AddTabContents(TabContentsWrapper* tab_contents,

[stevenjb, 2011/04/21 19:03:00]

nit: tab_contents_wrapper, or maybe just wrapper? To avoid confusing
tab_contents->tab_contents() below?

                                              WindowOpenDisposition disposition,
                                              const gfx::Rect& bounds,
                                              bool user_gesture) {
   if (blocked_contents_.size() == (kImpossibleNumberOfPopups - 1)) {
     delete tab_contents;
     VLOG(1) << "Warning: Renderer is sending more popups to us than should be "
                "possible. Renderer compromised?";
     return;
   }
 
   blocked_contents_.push_back(
       BlockedContent(tab_contents, disposition, bounds, user_gesture));
-  tab_contents->set_delegate(this);
-  // Since the new tab_contents will not be showed, call WasHidden to change
+  // TODO(avi): remove once TabContentsDelegate::GetConstrainingContents goes
+  // away.
+  tab_contents->tab_contents()->set_delegate(this);
+  tab_contents->blocked_content_tab_helper()->set_delegate(this);
+  // Since the new tab_contents will not be shown, call WasHidden to change
   // its status on both RenderViewHost and RenderView.
-  tab_contents->WasHidden();
-  if (blocked_contents_.size() == 1)
-    owner_->PopupNotificationVisibilityChanged(true);
+  tab_contents->tab_contents()->WasHidden();
 }
 
-void BlockedContentContainer::LaunchForContents(TabContents* tab_contents) {
+void BlockedContentContainer::LaunchForContents(
+    TabContentsWrapper* tab_contents) {

[stevenjb, 2011/04/21 19:03:00]

nit: wrapper?

   // Open the popup.
   for (BlockedContents::iterator i(blocked_contents_.begin());
        i != blocked_contents_.end(); ++i) {
     if (i->tab_contents == tab_contents) {
       // To support the owner blocking the content again we copy and erase
       // before attempting to add.
       BlockedContent content(*i);
       blocked_contents_.erase(i);
       i = blocked_contents_.end();
-      tab_contents->set_delegate(NULL);
+      // TODO(avi): remove once TabContentsDelegate::GetConstrainingContents
+      // goes away.
+      tab_contents->tab_contents()->set_delegate(NULL);
+      tab_contents->blocked_content_tab_helper()->set_delegate(NULL);
       // We needn't call WasRestored to change its status because the
       // TabContents::AddNewContents will do it.
-      owner_->AddOrBlockNewContents(tab_contents,
-                                    content.disposition,
-                                    content.bounds,
-                                    content.user_gesture);
+      owner_->tab_contents()->AddNewContents(
+          tab_contents->tab_contents(),
+          content.disposition,
+          content.bounds,
+          content.user_gesture);
       break;
     }
   }
-
-  if (blocked_contents_.empty())
-    Destroy();
 }
 
 size_t BlockedContentContainer::GetBlockedContentsCount() const {
   return blocked_contents_.size();
 }
 
 void BlockedContentContainer::GetBlockedContents(
-    std::vector<TabContents*>* blocked_contents) const {
+    std::vector<TabContentsWrapper*>* blocked_contents) const {
   DCHECK(blocked_contents);
   for (BlockedContents::const_iterator i(blocked_contents_.begin());
        i != blocked_contents_.end(); ++i)
     blocked_contents->push_back(i->tab_contents);
 }
 
-void BlockedContentContainer::Destroy() {
+void BlockedContentContainer::Clear() {
   for (BlockedContents::iterator i(blocked_contents_.begin());
        i != blocked_contents_.end(); ++i) {
-    TabContents* tab_contents = i->tab_contents;
-    tab_contents->set_delegate(NULL);
+    TabContentsWrapper* tab_contents = i->tab_contents;
+    // TODO(avi): remove once TabContentsDelegate::GetConstrainingContents goes
+    // away.
+    tab_contents->tab_contents()->set_delegate(NULL);
+    tab_contents->blocked_content_tab_helper()->set_delegate(NULL);
     delete tab_contents;
   }
   blocked_contents_.clear();
-  owner_->WillCloseBlockedContentContainer(this);
-  delete this;
 }
 
 // Overridden from TabContentsDelegate:
 void BlockedContentContainer::OpenURLFromTab(TabContents* source,
                                              const GURL& url,
                                              const GURL& referrer,
                                              WindowOpenDisposition disposition,
                                              PageTransition::Type transition) {
-  owner_->OpenURL(url, referrer, disposition, transition);
+  owner_->tab_contents()->OpenURL(url, referrer, disposition, transition);
 }
 
 void BlockedContentContainer::AddNewContents(TabContents* source,
                                              TabContents* new_contents,
                                              WindowOpenDisposition disposition,
                                              const gfx::Rect& initial_position,
                                              bool user_gesture) {
-  owner_->AddOrBlockNewContents(
+  owner_->tab_contents()->AddNewContents(
       new_contents, disposition, initial_position, user_gesture);
 }
 
 void BlockedContentContainer::CloseContents(TabContents* source) {
   for (BlockedContents::iterator i(blocked_contents_.begin());
        i != blocked_contents_.end(); ++i) {
-    TabContents* tab_contents = i->tab_contents;
-    if (tab_contents == source) {
-      tab_contents->set_delegate(NULL);
+    TabContentsWrapper* tab_contents = i->tab_contents;

[stevenjb, 2011/04/21 19:03:00]

nit: tab_contents_wrapper

+    if (tab_contents->tab_contents() == source) {
+      // TODO(avi): remove once TabContentsDelegate::GetConstrainingContents
+      // goes away.
+      tab_contents->tab_contents()->set_delegate(NULL);
+      tab_contents->blocked_content_tab_helper()->set_delegate(NULL);
       blocked_contents_.erase(i);
       delete tab_contents;
       break;
     }
   }
 }
 
 void BlockedContentContainer::MoveContents(TabContents* source,
                                            const gfx::Rect& new_bounds) {
   for (BlockedContents::iterator i(blocked_contents_.begin());
        i != blocked_contents_.end(); ++i) {
-    if (i->tab_contents == source) {
+    if (i->tab_contents->tab_contents() == source) {
       i->bounds = new_bounds;
       break;
     }
   }
 }
 
 bool BlockedContentContainer::IsPopup(const TabContents* source) const {
   // Assume everything added is a popup. This may turn out to be wrong, but
   // callers don't cache this information so it should be fine if the value ends
   // up changing.
   return true;
 }
 
 TabContents* BlockedContentContainer::GetConstrainingContents(
     TabContents* source) {
+  return owner_->tab_contents();
+}
+
+TabContentsWrapper* BlockedContentContainer::GetConstrainingContents(
+    TabContentsWrapper* source) {
   return owner_;
 }