Moved ios popup opening code from Tab to BlockedPopupTabHelper.

ios/chrome/browser/web/blocked_popup_tab_helper.mm

 // Copyright 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.
 
 #import "ios/chrome/browser/web/blocked_popup_tab_helper.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/format_macros.h"
@@ skipping 14 matching lines @@
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/image/image.h"
 
 DEFINE_WEB_STATE_USER_DATA_KEY(BlockedPopupTabHelper);
 
 namespace {
 // The infobar to display when a popup is blocked.
 class BlockPopupInfoBarDelegate : public ConfirmInfoBarDelegate {
  public:
   BlockPopupInfoBarDelegate(ios::ChromeBrowserState* browser_state,
+                            web::WebState* web_state,
                             const std::vector<web::BlockedPopupInfo>& popups)
-      : browser_state_(browser_state), popups_(popups) {}
+      : browser_state_(browser_state), web_state_(web_state), popups_(popups) {}
 
   ~BlockPopupInfoBarDelegate() override {}
 
   InfoBarIdentifier GetIdentifier() const override {
     return POPUP_BLOCKED_INFOBAR_DELEGATE;
   }
 
   gfx::Image GetIcon() const override {
     if (icon_.IsEmpty()) {
       icon_ = gfx::Image([UIImage imageNamed:@"infobar_popup_blocker"]);
@@ skipping 13 matching lines @@
 
   base::string16 GetButtonLabel(InfoBarButton button) const override {
     DCHECK(button == BUTTON_OK);
     return l10n_util::GetStringUTF16(IDS_IOS_POPUPS_ALWAYS_SHOW_MOBILE);
   }
 
   bool Accept() override {
     std::vector<web::BlockedPopupInfo>::iterator it;
     scoped_refptr<HostContentSettingsMap> host_content_map_settings(
         ios::HostContentSettingsMapFactory::GetForBrowserState(browser_state_));
-    for (auto& it : popups_) {
-      it.ShowPopup();
+    for (auto& popup : popups_) {
+      web::WebState::OpenURLParams params(
+          popup.url(), popup.referrer(), WindowOpenDisposition::NEW_POPUP,
+          ui::PAGE_TRANSITION_LINK, true /* is_renderer_initiated */);
+      web_state_->OpenURL(params);

[rohitrao (ping after 24h), 2017/02/28 22:51:57]

Is there any way for this |web_state_| pointer to go stale?  The infobar manager
should be destroyed along with the webstate, so I think the answer is no?

[Eugene But (OOO till 7-30), 2017/02/28 23:50:22]

Correct, the answer is no. I tested this in debugger.

       host_content_map_settings->SetContentSettingCustomScope(
-          ContentSettingsPattern::FromURL(it.referrer().url),
+          ContentSettingsPattern::FromURL(popup.referrer().url),
           ContentSettingsPattern::Wildcard(), CONTENT_SETTINGS_TYPE_POPUPS,
           std::string(), CONTENT_SETTING_ALLOW);
     }
     return true;
   }
 
   int GetButtons() const override { return BUTTON_OK; }
 
  private:
-  // The browser state to access user preferences.
   ios::ChromeBrowserState* browser_state_;
+  web::WebState* web_state_;
   // The popups to open.
   std::vector<web::BlockedPopupInfo> popups_;
   // The icon to display.
   mutable gfx::Image icon_;
 };
 }  // namespace
 
 BlockedPopupTabHelper::BlockedPopupTabHelper(web::WebState* web_state)
     : web_state_(web_state), infobar_(nullptr), scoped_observer_(this) {}
 
 BlockedPopupTabHelper::~BlockedPopupTabHelper() = default;
 
 bool BlockedPopupTabHelper::ShouldBlockPopup(const GURL& source_url) {
   HostContentSettingsMap* settings_map =
       ios::HostContentSettingsMapFactory::GetForBrowserState(GetBrowserState());
   ContentSetting setting = settings_map->GetContentSetting(
       source_url, source_url, CONTENT_SETTINGS_TYPE_POPUPS, std::string());
   return setting != CONTENT_SETTING_ALLOW;
 }
 
 void BlockedPopupTabHelper::HandlePopup(
     const web::BlockedPopupInfo& blocked_popup_info) {
+  DCHECK(ShouldBlockPopup(blocked_popup_info.referrer().url));
   popups_.push_back(blocked_popup_info);
   ShowInfoBar();
 }
 
 void BlockedPopupTabHelper::OnInfoBarRemoved(infobars::InfoBar* infobar,
                                              bool animate) {
   if (infobar == infobar_) {
     infobar_ = nullptr;
     popups_.clear();
     scoped_observer_.RemoveAll();
   }
 }
 
 void BlockedPopupTabHelper::OnManagerShuttingDown(
     infobars::InfoBarManager* infobar_manager) {
   scoped_observer_.Remove(infobar_manager);
 }
 
 void BlockedPopupTabHelper::ShowInfoBar() {
   infobars::InfoBarManager* infobar_manager =
       InfoBarManagerImpl::FromWebState(web_state_);
   if (!popups_.size() || !infobar_manager)
     return;
 
   RegisterAsInfoBarManagerObserverIfNeeded(infobar_manager);
 
   std::unique_ptr<BlockPopupInfoBarDelegate> delegate(
-      base::MakeUnique<BlockPopupInfoBarDelegate>(GetBrowserState(), popups_));
+      base::MakeUnique<BlockPopupInfoBarDelegate>(GetBrowserState(), web_state_,
+                                                  popups_));
   std::unique_ptr<infobars::InfoBar> infobar =
       infobar_manager->CreateConfirmInfoBar(std::move(delegate));
   if (infobar_) {
     infobar_ = infobar_manager->ReplaceInfoBar(infobar_, std::move(infobar));
   } else {
     infobar_ = infobar_manager->AddInfoBar(std::move(infobar));
   }
 }
 
 ios::ChromeBrowserState* BlockedPopupTabHelper::GetBrowserState() const {
   return ios::ChromeBrowserState::FromBrowserState(
       web_state_->GetBrowserState());
 }
 
 void BlockedPopupTabHelper::RegisterAsInfoBarManagerObserverIfNeeded(
     infobars::InfoBarManager* infobar_manager) {
   DCHECK(infobar_manager);
 
   if (scoped_observer_.IsObserving(infobar_manager)) {
     return;
   }
 
   // Verify that this object is never observing more than one InfoBarManager.
   DCHECK(!scoped_observer_.IsObservingSources());
   scoped_observer_.Add(infobar_manager);
 }