Remove kInstantProcess from renderer ContentSettingsObserver

chrome/renderer/content_settings_observer.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.
 
 #include "chrome/renderer/content_settings_observer.h"
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
-#include "chrome/common/chrome_switches.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/renderer/document_state.h"
 #include "content/public/renderer/navigation_state.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
 #include "third_party/WebKit/public/platform/WebPermissionCallbacks.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebDataSource.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
@@ skipping 123 matching lines @@
     }
   }
   NOTREACHED();
   return CONTENT_SETTING_DEFAULT;
 }
 
 }  // namespace
 
 ContentSettingsObserver::ContentSettingsObserver(
     content::RenderFrame* render_frame,
-    extensions::Dispatcher* extension_dispatcher)
+    extensions::Dispatcher* extension_dispatcher,
+    bool should_whitelist)
     : content::RenderFrameObserver(render_frame),
       content::RenderFrameObserverTracker<ContentSettingsObserver>(
           render_frame),
 #if defined(ENABLE_EXTENSIONS)
       extension_dispatcher_(extension_dispatcher),
 #endif
       allow_displaying_insecure_content_(false),
       allow_running_insecure_content_(false),
       content_setting_rules_(NULL),
       is_interstitial_page_(false),
       npapi_plugins_blocked_(false),
-      current_request_id_(0) {
+      current_request_id_(0),
+      should_whitelist_(should_whitelist) {
   ClearBlockedContentSettings();
   render_frame->GetWebFrame()->setPermissionClient(this);
 
   if (render_frame->GetRenderView()->GetMainRenderFrame() != render_frame) {
     // Copy all the settings from the main render frame to avoid race conditions
     // when initializing this data. See http://crbug.com/333308.
     ContentSettingsObserver* parent = ContentSettingsObserver::Get(
         render_frame->GetRenderView()->GetMainRenderFrame());
     allow_displaying_insecure_content_ =
         parent->allow_displaying_insecure_content_;
@@ skipping 129 matching lines @@
       GURL(frame->top()->document().securityOrigin().toString())));
 }
 
 bool ContentSettingsObserver::allowImage(bool enabled_per_settings,
                                          const WebURL& image_url) {
   bool allow = enabled_per_settings;
   if (enabled_per_settings) {
     if (is_interstitial_page_)
       return true;
 
-    if (IsWhitelistedForContentSettings(render_frame()))
+    if (IsWhitelistedForContentSettings())
       return true;
 
     if (content_setting_rules_) {
       GURL secondary_url(image_url);
       allow =
           GetContentSettingFromRules(content_setting_rules_->image_rules,
                                      render_frame()->GetWebFrame(),
                                      secondary_url) != CONTENT_SETTING_BLOCK;
     }
   }
@@ skipping 37 matching lines @@
   // |IsWhitelistedForContentSettings|; if there is only the default rule
   // allowing all scripts, it's quicker this way.
   bool allow = true;
   if (content_setting_rules_) {
     ContentSetting setting = GetContentSettingFromRules(
         content_setting_rules_->script_rules,
         frame,
         GURL(frame->document().securityOrigin().toString()));
     allow = setting != CONTENT_SETTING_BLOCK;
   }
-  allow = allow || IsWhitelistedForContentSettings(render_frame());
+  allow = allow || IsWhitelistedForContentSettings();
 
   cached_script_permissions_[frame] = allow;
   return allow;
 }
 
 bool ContentSettingsObserver::allowScriptFromSource(
     bool enabled_per_settings,
     const blink::WebURL& script_url) {
   if (!enabled_per_settings)
     return false;
   if (is_interstitial_page_)
     return true;
 
   bool allow = true;
   if (content_setting_rules_) {
     ContentSetting setting =
         GetContentSettingFromRules(content_setting_rules_->script_rules,
                                    render_frame()->GetWebFrame(),
                                    GURL(script_url));
     allow = setting != CONTENT_SETTING_BLOCK;
   }
-  return allow || IsWhitelistedForContentSettings(render_frame());
+  return allow || IsWhitelistedForContentSettings();
 }
 
 bool ContentSettingsObserver::allowStorage(bool local) {
   WebFrame* frame = render_frame()->GetWebFrame();
   if (frame->document().securityOrigin().isUnique() ||
       frame->top()->document().securityOrigin().isUnique())
     return false;
   bool result = false;
 
   StoragePermissionsKey key(
@@ skipping 261 matching lines @@
     return NULL;
 
   const std::string extension_id = origin.host().utf8().data();
   if (!extension_dispatcher_->IsExtensionActive(extension_id))
     return NULL;
 
   return extension_dispatcher_->extensions()->GetByID(extension_id);
 }
 #endif
 
-bool ContentSettingsObserver::IsWhitelistedForContentSettings(
-    content::RenderFrame* frame) {
-  // Whitelist Instant processes.
-  if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kInstantProcess))
+bool ContentSettingsObserver::IsWhitelistedForContentSettings() const {
+  if (should_whitelist_)
     return true;
 
   // Whitelist ftp directory listings, as they require JavaScript to function
   // properly.
-  if (frame->IsFTPDirectoryListing())
+  if (render_frame()->IsFTPDirectoryListing())
     return true;
 
-  WebFrame* web_frame = frame->GetWebFrame();
+  WebFrame* web_frame = render_frame()->GetWebFrame();
   return IsWhitelistedForContentSettings(web_frame->document().securityOrigin(),
                                          web_frame->document().url());
 }
 
 bool ContentSettingsObserver::IsWhitelistedForContentSettings(
     const WebSecurityOrigin& origin,
     const GURL& document_url) {
   if (document_url == GURL(content::kUnreachableWebDataURL))
     return true;
 
@@ skipping 18 matching lines @@
 
   // If the scheme is file:, an empty file name indicates a directory listing,
   // which requires JavaScript to function properly.
   if (EqualsASCII(origin.protocol(), url::kFileScheme)) {
     return document_url.SchemeIs(url::kFileScheme) &&
            document_url.ExtractFileName().empty();
   }
 
   return false;
 }