Use InterstitialPage through a delegate interface instead of deriving from it.

chrome/browser/safe_browsing/safe_browsing_blocking_page.cc

 // Copyright (c) 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.
 //
 // Implementation of the SafeBrowsingBlockingPage class.
 
 #include "chrome/browser/safe_browsing/safe_browsing_blocking_page.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/i18n/rtl.h"
 #include "base/lazy_instance.h"
 #include "base/string_number_conversions.h"
 #include "base/string_piece.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/google/google_util.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/renderer_preferences_util.h"
 #include "chrome/browser/safe_browsing/malware_details.h"
 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
 #include "chrome/browser/tab_contents/tab_util.h"
 #include "chrome/browser/ui/webui/ntp/new_tab_ui.h"
 #include "chrome/common/jstemplate_builder.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
+#include "content/browser/tab_contents/interstitial_page.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "grit/browser_resources.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "net/base/escape.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
@@ skipping 89 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(SafeBrowsingBlockingPageFactoryImpl);
 };
 
 static base::LazyInstance<SafeBrowsingBlockingPageFactoryImpl>
     g_safe_browsing_blocking_page_factory_impl = LAZY_INSTANCE_INITIALIZER;
 
 SafeBrowsingBlockingPage::SafeBrowsingBlockingPage(
     SafeBrowsingService* sb_service,
     WebContents* web_contents,
     const UnsafeResourceList& unsafe_resources)
-    : ChromeInterstitialPage(web_contents,
-                             IsMainPageLoadBlocked(unsafe_resources),
-                             unsafe_resources[0].url),
-      malware_details_proceed_delay_ms_(
+    : malware_details_proceed_delay_ms_(
           kMalwareDetailsProceedDelayMilliSeconds),
       sb_service_(sb_service),
       report_loop_(NULL),
       is_main_frame_load_blocked_(IsMainPageLoadBlocked(unsafe_resources)),
-      unsafe_resources_(unsafe_resources) {
+      unsafe_resources_(unsafe_resources),
+      proceeded_(false),
+      web_contents_(web_contents),
+      url_(unsafe_resources[0].url) {
   RecordUserAction(SHOW);
   if (!is_main_frame_load_blocked_) {
     navigation_entry_index_to_remove_ =
-        tab()->GetController().GetLastCommittedEntryIndex();
+        web_contents->GetController().GetLastCommittedEntryIndex();
   } else {
     navigation_entry_index_to_remove_ = -1;
   }
 
   // Start computing malware details. They will be sent only
   // if the user opts-in on the blocking page later.
   // If there's more than one malicious resources, it means the user
   // clicked through the first warning, so we don't prepare additional
   // reports.
   if (unsafe_resources.size() == 1 &&
       unsafe_resources[0].threat_type == SafeBrowsingService::URL_MALWARE &&
       malware_details_ == NULL &&
       CanShowMalwareDetailsOption()) {
     malware_details_ = MalwareDetails::NewMalwareDetails(
-        sb_service_, tab(), unsafe_resources[0]);
+        sb_service_, web_contents, unsafe_resources[0]);
   }
+
+  interstitial_page_ = InterstitialPage::Create(
+      web_contents, IsMainPageLoadBlocked(unsafe_resources), url_, this);
 }
 
 bool SafeBrowsingBlockingPage::CanShowMalwareDetailsOption() {
-  return (!tab()->GetBrowserContext()->IsOffTheRecord() &&
-          tab()->GetURL().SchemeIs(chrome::kHttpScheme));
+  return (!web_contents_->GetBrowserContext()->IsOffTheRecord() &&
+          web_contents_->GetURL().SchemeIs(chrome::kHttpScheme));
 }
 
 SafeBrowsingBlockingPage::~SafeBrowsingBlockingPage() {
 }
 
 std::string SafeBrowsingBlockingPage::GetHTMLContents() {
   // Load the HTML page and create the template components.
   DictionaryValue strings;
   ResourceBundle& rb = ResourceBundle::GetSharedInstance();
   std::string html;
@@ skipping 79 matching lines @@
   strings->Set("errors", error_strings);
   DCHECK(phishing || malware);
 
   if (malware && phishing) {
     PopulateStringDictionary(
         strings,
         // Use the malware headline, it is the scariest one.
         l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MULTI_THREAT_TITLE),
         l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_HEADLINE),
         l10n_util::GetStringFUTF16(IDS_SAFE_BROWSING_MULTI_THREAT_DESCRIPTION1,
-                                   UTF8ToUTF16(tab()->GetURL().host())),
+                                   UTF8ToUTF16(web_contents_->GetURL().host())),
         l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MULTI_THREAT_DESCRIPTION2),
         string16());
   } else if (malware) {
     // Just malware.
     PopulateStringDictionary(
         strings,
         l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_TITLE),
         l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_HEADLINE),
         l10n_util::GetStringFUTF16(IDS_SAFE_BROWSING_MULTI_MALWARE_DESCRIPTION1,
-                                   UTF8ToUTF16(tab()->GetURL().host())),
+                                   UTF8ToUTF16(web_contents_->GetURL().host())),
         l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MULTI_MALWARE_DESCRIPTION2),
         l10n_util::GetStringUTF16(
             IDS_SAFE_BROWSING_MULTI_MALWARE_DESCRIPTION3));
   } else {
     // Just phishing.
     PopulateStringDictionary(
         strings,
         l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_TITLE),
         l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_HEADLINE),
         l10n_util::GetStringFUTF16(
             IDS_SAFE_BROWSING_MULTI_PHISHING_DESCRIPTION1,
-            UTF8ToUTF16(tab()->GetURL().host())),
+            UTF8ToUTF16(web_contents_->GetURL().host())),
         string16(),
         string16());
   }
 
   strings->SetString("confirm_text",
                      l10n_util::GetStringUTF16(
                          IDS_SAFE_BROWSING_MULTI_MALWARE_DESCRIPTION_AGREE));
   strings->SetString("continue_button",
                      l10n_util::GetStringUTF16(
                          IDS_SAFE_BROWSING_MULTI_MALWARE_PROCEED_BUTTON));
   strings->SetString("back_button",
       l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_BACK_BUTTON));
   strings->SetString("textdirection", base::i18n::IsRTL() ? "rtl" : "ltr");
 }
 
 void SafeBrowsingBlockingPage::PopulateMalwareStringDictionary(
     DictionaryValue* strings) {
   std::string diagnostic_link = base::StringPrintf(kSbDiagnosticHtml,
       l10n_util::GetStringUTF8(
         IDS_SAFE_BROWSING_MALWARE_DIAGNOSTIC_PAGE).c_str());
 
-  strings->SetString("badURL", url().host());
+  strings->SetString("badURL", url_.host());
   // Check to see if we're blocking the main page, or a sub-resource on the
   // main page.
   string16 description1, description3, description5;
   if (is_main_frame_load_blocked_) {
     description1 = l10n_util::GetStringFUTF16(
-        IDS_SAFE_BROWSING_MALWARE_DESCRIPTION1, UTF8ToUTF16(url().host()));
+        IDS_SAFE_BROWSING_MALWARE_DESCRIPTION1, UTF8ToUTF16(url_.host()));
   } else {
     description1 = l10n_util::GetStringFUTF16(
         IDS_SAFE_BROWSING_MALWARE_DESCRIPTION4,
-        UTF8ToUTF16(tab()->GetURL().host()),
-        UTF8ToUTF16(url().host()));
+        UTF8ToUTF16(web_contents_->GetURL().host()),
+        UTF8ToUTF16(url_.host()));
   }
 
   std::string proceed_link = base::StringPrintf(kPLinkHtml,
       l10n_util::GetStringUTF8(IDS_SAFE_BROWSING_MALWARE_PROCEED_LINK).c_str());
   description3 =
       l10n_util::GetStringFUTF16(IDS_SAFE_BROWSING_MALWARE_DESCRIPTION3,
                                  UTF8ToUTF16(proceed_link));
 
   PopulateStringDictionary(
       strings,
       l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_TITLE),
       l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_HEADLINE),
       description1,
       l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_DESCRIPTION2),
       description3);
 
   description5 =
       l10n_util::GetStringFUTF16(IDS_SAFE_BROWSING_MALWARE_DESCRIPTION5,
-                                 UTF8ToUTF16(url().host()),
-                                 UTF8ToUTF16(url().host()),
+                                 UTF8ToUTF16(url_.host()),
+                                 UTF8ToUTF16(url_.host()),
                                  UTF8ToUTF16(diagnostic_link));
 
   strings->SetString("description5", description5);
 
   strings->SetString("back_button",
       l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_BACK_BUTTON));
   strings->SetString("proceed_link",
       l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_PROCEED_LINK));
   strings->SetString("textdirection", base::i18n::IsRTL() ? "rtl" : "ltr");
 
   if (!CanShowMalwareDetailsOption()) {
     strings->SetBoolean(kDisplayCheckBox, false);
   } else {
     // Show the checkbox for sending malware details.
     strings->SetBoolean(kDisplayCheckBox, true);
 
     std::string privacy_link = base::StringPrintf(
         kPrivacyLinkHtml,
         l10n_util::GetStringUTF8(
             IDS_SAFE_BROWSING_PRIVACY_POLICY_PAGE).c_str());
 
     strings->SetString("confirm_text",
                        l10n_util::GetStringFUTF16(
                            IDS_SAFE_BROWSING_MALWARE_REPORTING_AGREE,
                            UTF8ToUTF16(privacy_link)));
 
-    Profile* profile = Profile::FromBrowserContext(tab()->GetBrowserContext());
+    Profile* profile = Profile::FromBrowserContext(
+        web_contents_->GetBrowserContext());
     const PrefService::Preference* pref =
         profile->GetPrefs()->FindPreference(
             prefs::kSafeBrowsingReportingEnabled);
 
     bool value;
     if (pref && pref->GetValue()->GetAsBoolean(&value) && value) {
       strings->SetString(kBoxChecked, "yes");
     } else {
       strings->SetString(kBoxChecked, "");
     }
   }
 }
 
 void SafeBrowsingBlockingPage::PopulatePhishingStringDictionary(
     DictionaryValue* strings) {
   std::string proceed_link = base::StringPrintf(
       kPLinkHtml,
       l10n_util::GetStringUTF8(
           IDS_SAFE_BROWSING_PHISHING_PROCEED_LINK).c_str());
   string16 description3 = l10n_util::GetStringFUTF16(
       IDS_SAFE_BROWSING_PHISHING_DESCRIPTION3,
       UTF8ToUTF16(proceed_link));
 
   PopulateStringDictionary(
       strings,
       l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_TITLE),
       l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_HEADLINE),
       l10n_util::GetStringFUTF16(IDS_SAFE_BROWSING_PHISHING_DESCRIPTION1,
-                                 UTF8ToUTF16(url().host())),
+                                 UTF8ToUTF16(url_.host())),
       l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_DESCRIPTION2),
       description3);
 
   strings->SetString("back_button",
       l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_BACK_BUTTON));
   strings->SetString("report_error",
       l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_REPORT_ERROR));
   strings->SetString("textdirection", base::i18n::IsRTL() ? "rtl" : "ltr");
 }
 
@@ skipping 23 matching lines @@
       url = google_util::AppendGoogleLocaleParam(GURL(kLearnMoreMalwareUrl));
     } else if (threat_type == SafeBrowsingService::URL_PHISHING ||
                threat_type == SafeBrowsingService::CLIENT_SIDE_PHISHING_URL) {
       url = google_util::AppendGoogleLocaleParam(GURL(kLearnMorePhishingUrl));
     } else {
       NOTREACHED();
     }
 
     OpenURLParams params(
         url, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_LINK, false);
-    tab()->OpenURL(params);
+    web_contents_->OpenURL(params);
     return;
   }
 
   if (command == kShowPrivacyCommand) {
     // User pressed "Safe Browsing privacy policy".
     GURL url(kSbPrivacyPolicyUrl);
     OpenURLParams params(
         url, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_LINK, false);
-    tab()->OpenURL(params);
+    web_contents_->OpenURL(params);
     return;
   }
 
   if (command == kProceedCommand) {
-    Proceed();
+    interstitial_page_->Proceed();
     // We are deleted after this.
     return;
   }
 
   if (command == kTakeMeBackCommand) {
     if (is_main_frame_load_blocked_) {
       // If the load is blocked, we want to close the interstitial and discard
       // the pending entry.
-      DontProceed();
+      interstitial_page_->DontProceed();
       // We are deleted after this.
       return;
     }
 
     // Otherwise the offending entry has committed, and we need to go back or
     // to a safe page.  We will close the interstitial when that page commits.
-    if (tab()->GetController().CanGoBack()) {
-      tab()->GetController().GoBack();
+    if (web_contents_->GetController().CanGoBack()) {
+      web_contents_->GetController().GoBack();
     } else {
-      tab()->GetController().LoadURL(GURL(chrome::kChromeUINewTabURL),
-                                     content::Referrer(),
-                                     content::PAGE_TRANSITION_START_PAGE,
-                                     std::string());
+      web_contents_->GetController().LoadURL(
+          GURL(chrome::kChromeUINewTabURL),
+          content::Referrer(),
+          content::PAGE_TRANSITION_START_PAGE,
+          std::string());
     }
     return;
   }
 
   // The "report error" and "show diagnostic" commands can have a number
   // appended to them, which is the index of the element they apply to.
   int element_index = 0;
   size_t colon_index = command.find(':');
   if (colon_index != std::string::npos) {
     DCHECK(colon_index < command.size() - 1);
@@ skipping 20 matching lines @@
     DCHECK(threat_type == SafeBrowsingService::URL_PHISHING ||
            threat_type == SafeBrowsingService::CLIENT_SIDE_PHISHING_URL);
     GURL report_url =
         safe_browsing_util::GeneratePhishingReportUrl(
             kSbReportPhishingErrorUrl,
             bad_url_spec,
             threat_type == SafeBrowsingService::CLIENT_SIDE_PHISHING_URL);
     OpenURLParams params(
         report_url, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_LINK,
         false);
-    tab()->OpenURL(params);
+    web_contents_->OpenURL(params);
     return;
   }
 
   if (command == kShowDiagnosticCommand) {
     // We're going to take the user to Google's SafeBrowsing diagnostic page.
     std::string diagnostic =
         base::StringPrintf(kSbDiagnosticUrl,
             net::EscapeQueryParamValue(bad_url_spec, true).c_str());
     GURL diagnostic_url(diagnostic);
     diagnostic_url = google_util::AppendGoogleLocaleParam(diagnostic_url);
     DCHECK(unsafe_resources_[element_index].threat_type ==
            SafeBrowsingService::URL_MALWARE);
     OpenURLParams params(
         diagnostic_url, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_LINK,
         false);
-    tab()->OpenURL(params);
+    web_contents_->OpenURL(params);
     return;
   }
 
   NOTREACHED() << "Unexpected command: " << command;
 }
 
+void SafeBrowsingBlockingPage::OverrideRendererPrefs(
+      content::RendererPreferences* prefs) {
+  Profile* profile = Profile::FromBrowserContext(
+      web_contents_->GetBrowserContext());
+  renderer_preferences_util::UpdateFromSystemSettings(prefs, profile);
+ }
+
 void SafeBrowsingBlockingPage::SetReportingPreference(bool report) {
-  Profile* profile = Profile::FromBrowserContext(tab()->GetBrowserContext());
+  Profile* profile = Profile::FromBrowserContext(
+      web_contents_->GetBrowserContext());
   PrefService* pref = profile->GetPrefs();
   pref->SetBoolean(prefs::kSafeBrowsingReportingEnabled, report);
 }
 
-void SafeBrowsingBlockingPage::Proceed() {
+void SafeBrowsingBlockingPage::OnProceed() {
+  proceeded_ = true;
   RecordUserAction(PROCEED);
   // Send the malware details, if we opted to.
   FinishMalwareDetails(malware_details_proceed_delay_ms_);
 
   NotifySafeBrowsingService(sb_service_, unsafe_resources_, true);
 
   // Check to see if some new notifications of unsafe resources have been
   // received while we were showing the interstitial.
   UnsafeResourceMap* unsafe_resource_map = GetUnsafeResourcesMap();
-  UnsafeResourceMap::iterator iter = unsafe_resource_map->find(tab());
+  UnsafeResourceMap::iterator iter = unsafe_resource_map->find(web_contents_);
   SafeBrowsingBlockingPage* blocking_page = NULL;
   if (iter != unsafe_resource_map->end() && !iter->second.empty()) {
     // Build an interstitial for all the unsafe resources notifications.
     // Don't show it now as showing an interstitial while an interstitial is
     // already showing would cause DontProceed() to be invoked.
-    blocking_page = factory_->CreateSafeBrowsingPage(sb_service_, tab(),
+    blocking_page = factory_->CreateSafeBrowsingPage(sb_service_, web_contents_,
                                                      iter->second);
     unsafe_resource_map->erase(iter);
   }
 
-  InterstitialPage::Proceed();
-  // We are now deleted.
-
   // Now that this interstitial is gone, we can show the new one.
   if (blocking_page)
-    blocking_page->Show();
+    blocking_page->interstitial_page_->Show();
 }
 
-void SafeBrowsingBlockingPage::DontProceed() {
-  DCHECK(action_taken() != DONT_PROCEED_ACTION);
+void SafeBrowsingBlockingPage::OnDontProceed() {
   // We could have already called Proceed(), in which case we must not notify
   // the SafeBrowsingService again, as the client has been deleted.
-  if (action_taken() == PROCEED_ACTION) {
-    // We still want to hide the interstitial page.
-    InterstitialPage::DontProceed();
-    // We are now deleted.
+  if (proceeded_)
     return;
-  }
 
   RecordUserAction(DONT_PROCEED);
   // Send the malware details, if we opted to.
   FinishMalwareDetails(0);  // No delay
 
   NotifySafeBrowsingService(sb_service_, unsafe_resources_, false);
 
   // The user does not want to proceed, clear the queued unsafe resources
   // notifications we received while the interstitial was showing.
   UnsafeResourceMap* unsafe_resource_map = GetUnsafeResourcesMap();
-  UnsafeResourceMap::iterator iter = unsafe_resource_map->find(tab());
+  UnsafeResourceMap::iterator iter = unsafe_resource_map->find(web_contents_);
   if (iter != unsafe_resource_map->end() && !iter->second.empty()) {
     NotifySafeBrowsingService(sb_service_, iter->second, false);
     unsafe_resource_map->erase(iter);
   }
 
   // We don't remove the navigation entry if the tab is being destroyed as this
   // would trigger a navigation that would cause trouble as the render view host
   // for the tab has by then already been destroyed.  We also don't delete the
   // current entry if it has been committed again, which is possible on a page
   // that had a subresource warning.
   int last_committed_index =
-      tab()->GetController().GetLastCommittedEntryIndex();
+      web_contents_->GetController().GetLastCommittedEntryIndex();
   if (navigation_entry_index_to_remove_ != -1 &&
       navigation_entry_index_to_remove_ != last_committed_index &&
-      !tab()->IsBeingDestroyed()) {
-    tab()->GetController().RemoveEntryAtIndex(
+      !web_contents_->IsBeingDestroyed()) {
+    web_contents_->GetController().RemoveEntryAtIndex(
         navigation_entry_index_to_remove_);
     navigation_entry_index_to_remove_ = -1;
   }
-  InterstitialPage::DontProceed();
-  // We are now deleted.
 }
 
 void SafeBrowsingBlockingPage::RecordUserAction(BlockingPageEvent event) {
   // Determine the interstitial type from the blocked resources.
   // This is the same logic that is used to actually construct the
   // page contents; we can look at the title to see which type of
   // interstitial is being displayed.
   DictionaryValue strings;
   PopulateMultipleThreatStringDictionary(&strings);
 
@@ skipping 28 matching lines @@
       NOTREACHED() << "Unexpected event: " << event;
   }
 
   content::RecordComputedAction(action);
 }
 
 void SafeBrowsingBlockingPage::FinishMalwareDetails(int64 delay_ms) {
   if (malware_details_ == NULL)
     return;  // Not all interstitials have malware details (eg phishing).
 
-  Profile* profile = Profile::FromBrowserContext(tab()->GetBrowserContext());
+  Profile* profile = Profile::FromBrowserContext(
+      web_contents_->GetBrowserContext());
   const PrefService::Preference* pref =
       profile->GetPrefs()->FindPreference(prefs::kSafeBrowsingReportingEnabled);
 
   bool value;
   if (pref && pref->GetValue()->GetAsBoolean(&value) && value) {
     // Finish the malware details collection, send it over.
     BrowserThread::PostDelayedTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(&MalwareDetails::FinishCollection, malware_details_.get()),
         delay_ms);
@@ skipping 38 matching lines @@
     // There are no interstitial currently showing in that tab, go ahead and
     // show this interstitial.
     std::vector<SafeBrowsingService::UnsafeResource> resources;
     resources.push_back(unsafe_resource);
     // Set up the factory if this has not been done already (tests do that
     // before this method is called).
     if (!factory_)
       factory_ = g_safe_browsing_blocking_page_factory_impl.Pointer();
     SafeBrowsingBlockingPage* blocking_page =
         factory_->CreateSafeBrowsingPage(sb_service, web_contents, resources);
-    blocking_page->Show();
+    blocking_page->interstitial_page_->Show();
     return;
   }
 
   // This is an interstitial for a page's resource, let's queue it.
   UnsafeResourceMap* unsafe_resource_map = GetUnsafeResourcesMap();
   (*unsafe_resource_map)[web_contents].push_back(unsafe_resource);
 }
 
 // static
 bool SafeBrowsingBlockingPage::IsMainPageLoadBlocked(
     const UnsafeResourceList& unsafe_resources) {
   // Client-side phishing detection interstitials never block the main frame
   // load, since they happen after the page is finished loading.
   if (unsafe_resources[0].threat_type ==
       SafeBrowsingService::CLIENT_SIDE_PHISHING_URL) {
     return false;
   }
 
   // Otherwise, check the threat type.
   return unsafe_resources.size() == 1 && !unsafe_resources[0].is_subresource;
 }