Chrome side changes to removing WebFrame parameter from WebPermissionClient, since it's redundant n…

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"
@@ skipping 215 matching lines @@
     temporarily_allowed_plugins_.clear();
   }
 
   GURL url = frame->document().url();
   // If we start failing this DCHECK, please makes sure we don't regress
   // this bug: http://code.google.com/p/chromium/issues/detail?id=79304
   DCHECK(frame->document().securityOrigin().toString() == "null" ||
          !url.SchemeIs(content::kDataScheme));
 }
 
-bool ContentSettingsObserver::allowDatabase(WebFrame* frame,
-                                            const WebString& name,
+bool ContentSettingsObserver::allowDatabase(
+    blink::WebFrame* frame,
+    const blink::WebString& name,
+    const blink::WebString& display_name,
+    unsigned long estimated_size) {
+  return allowDatabase(name, display_name, estimated_size);
+}
+
+bool ContentSettingsObserver::allowFileSystem(blink::WebFrame* frame) {
+  return allowFileSystem();
+}
+
+bool ContentSettingsObserver::allowImage(blink::WebFrame* frame,
+                                         bool enabled_per_settings,
+                                         const blink::WebURL& image_url) {
+  return allowImage(enabled_per_settings, image_url);
+}
+
+bool ContentSettingsObserver::allowIndexedDB(
+    blink::WebFrame* frame,
+    const blink::WebString& name,
+    const blink::WebSecurityOrigin& origin) {
+  return allowIndexedDB(name, origin);
+}
+
+bool ContentSettingsObserver::allowPlugins(blink::WebFrame* frame,
+                                           bool enabled_per_settings) {
+  return allowPlugins(enabled_per_settings);
+}
+
+bool ContentSettingsObserver::allowScript(blink::WebFrame* frame,
+                                          bool enabled_per_settings) {
+  return allowScript(enabled_per_settings);
+}
+
+bool ContentSettingsObserver::allowScriptFromSource(
+    blink::WebFrame* frame,
+    bool enabled_per_settings,
+    const blink::WebURL& script_url) {
+  return allowScriptFromSource(enabled_per_settings, script_url);
+}
+
+bool ContentSettingsObserver::allowStorage(blink::WebFrame* frame, bool local) {
+  return allowStorage(local);
+}
+
+bool ContentSettingsObserver::allowReadFromClipboard(blink::WebFrame* frame,
+                                                     bool default_value) {
+  return allowReadFromClipboard(default_value);
+}
+
+bool ContentSettingsObserver::allowWriteToClipboard(blink::WebFrame* frame,
+                                                    bool default_value) {
+  return allowWriteToClipboard(default_value);
+}
+
+bool ContentSettingsObserver::allowWebComponents(blink::WebFrame* frame,
+                                                 bool default_value) {
+  return allowWebComponents(default_value);
+}
+
+bool ContentSettingsObserver::allowMutationEvents(blink::WebFrame* frame,
+                                                  bool default_value) {
+  return allowMutationEvents(default_value);
+}
+
+bool ContentSettingsObserver::allowPushState(blink::WebFrame* frame) {
+  return allowPushState();
+}
+
+void ContentSettingsObserver::didNotAllowPlugins(blink::WebFrame* frame) {
+  return didNotAllowPlugins();
+}
+
+void ContentSettingsObserver::didNotAllowScript(blink::WebFrame* frame) {
+  return didNotAllowScript();
+}
+
+bool ContentSettingsObserver::allowDisplayingInsecureContent(
+    blink::WebFrame* frame,
+    bool allowed_per_settings,
+    const blink::WebSecurityOrigin& context,
+    const blink::WebURL& url) {
+  return allowDisplayingInsecureContent(allowed_per_settings, context, url);
+}
+
+bool ContentSettingsObserver::allowRunningInsecureContent(
+    blink::WebFrame* frame,
+    bool allowed_per_settings,
+    const blink::WebSecurityOrigin& context,
+    const blink::WebURL& url) {
+  return allowRunningInsecureContent(allowed_per_settings, context, url);
+}
+
+bool ContentSettingsObserver::allowDatabase(const WebString& name,
                                             const WebString& display_name,
                                             unsigned long estimated_size) {
+  WebFrame* frame = render_frame()->GetWebFrame();
   if (frame->document().securityOrigin().isUnique() ||
       frame->top()->document().securityOrigin().isUnique())
     return false;
 
   bool result = false;
   Send(new ChromeViewHostMsg_AllowDatabase(
       routing_id(), GURL(frame->document().securityOrigin().toString()),
       GURL(frame->top()->document().securityOrigin().toString()),
       name, display_name, &result));
   return result;
 }
 
-bool ContentSettingsObserver::allowFileSystem(WebFrame* frame) {
+bool ContentSettingsObserver::allowFileSystem() {
+  WebFrame* frame = render_frame()->GetWebFrame();
   if (frame->document().securityOrigin().isUnique() ||
       frame->top()->document().securityOrigin().isUnique())
     return false;
 
   bool result = false;
   Send(new ChromeViewHostMsg_AllowFileSystem(
       routing_id(), GURL(frame->document().securityOrigin().toString()),
       GURL(frame->top()->document().securityOrigin().toString()), &result));
   return result;
 }
 
-bool ContentSettingsObserver::allowImage(WebFrame* frame,
-                                         bool enabled_per_settings,
+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;
+
+    WebFrame* frame = render_frame()->GetWebFrame();
     if (IsWhitelistedForContentSettings(frame))
       return true;
 
     if (content_setting_rules_) {
       GURL secondary_url(image_url);
       allow = GetContentSettingFromRules(
           content_setting_rules_->image_rules,
           frame, secondary_url) != CONTENT_SETTING_BLOCK;
     }
   }
   if (!allow)
     DidBlockContentType(CONTENT_SETTINGS_TYPE_IMAGES);
   return allow;
 }
 
-bool ContentSettingsObserver::allowIndexedDB(WebFrame* frame,
-                                             const WebString& name,
+bool ContentSettingsObserver::allowIndexedDB(const WebString& name,
                                              const WebSecurityOrigin& origin) {
+  WebFrame* frame = render_frame()->GetWebFrame();
   if (frame->document().securityOrigin().isUnique() ||
       frame->top()->document().securityOrigin().isUnique())
     return false;
 
   bool result = false;
   Send(new ChromeViewHostMsg_AllowIndexedDB(
       routing_id(), GURL(frame->document().securityOrigin().toString()),
       GURL(frame->top()->document().securityOrigin().toString()),
       name, &result));
   return result;
 }
 
-bool ContentSettingsObserver::allowPlugins(WebFrame* frame,
-                                           bool enabled_per_settings) {
+bool ContentSettingsObserver::allowPlugins(bool enabled_per_settings) {
   return enabled_per_settings;
 }
 
-bool ContentSettingsObserver::allowScript(WebFrame* frame,
-                                          bool enabled_per_settings) {
+bool ContentSettingsObserver::allowScript(bool enabled_per_settings) {
   if (!enabled_per_settings)
     return false;
   if (is_interstitial_page_)
     return true;
 
+  WebFrame* frame = render_frame()->GetWebFrame();
   std::map<WebFrame*, bool>::const_iterator it =
       cached_script_permissions_.find(frame);
   if (it != cached_script_permissions_.end())
     return it->second;
 
   // Evaluate the content setting rules before
   // |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(frame);
 
   cached_script_permissions_[frame] = allow;
   return allow;
 }
 
 bool ContentSettingsObserver::allowScriptFromSource(
-    WebFrame* frame,
     bool enabled_per_settings,
     const blink::WebURL& script_url) {
   if (!enabled_per_settings)
     return false;
   if (is_interstitial_page_)
     return true;
 
   bool allow = true;
+  WebFrame* frame = render_frame()->GetWebFrame();
   if (content_setting_rules_) {
     ContentSetting setting = GetContentSettingFromRules(
         content_setting_rules_->script_rules,
         frame,
         GURL(script_url));
     allow = setting != CONTENT_SETTING_BLOCK;
   }
   return allow || IsWhitelistedForContentSettings(frame);
 }
 
-bool ContentSettingsObserver::allowStorage(WebFrame* frame, bool local) {
+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(
       GURL(frame->document().securityOrigin().toString()), local);
   std::map<StoragePermissionsKey, bool>::const_iterator permissions =
       cached_storage_permissions_.find(key);
   if (permissions != cached_storage_permissions_.end())
     return permissions->second;
 
   Send(new ChromeViewHostMsg_AllowDOMStorage(
       routing_id(), GURL(frame->document().securityOrigin().toString()),
       GURL(frame->top()->document().securityOrigin().toString()),
       local, &result));
   cached_storage_permissions_[key] = result;
   return result;
 }
 
-bool ContentSettingsObserver::allowReadFromClipboard(WebFrame* frame,
-                                                     bool default_value) {
+bool ContentSettingsObserver::allowReadFromClipboard(bool default_value) {
   bool allowed = false;
+  WebFrame* frame = render_frame()->GetWebFrame();
   // TODO(dcheng): Should we consider a toURL() method on WebSecurityOrigin?
   Send(new ChromeViewHostMsg_CanTriggerClipboardRead(
       GURL(frame->document().securityOrigin().toString()), &allowed));
   return allowed;
 }
 
-bool ContentSettingsObserver::allowWriteToClipboard(WebFrame* frame,
-                                                    bool default_value) {
+bool ContentSettingsObserver::allowWriteToClipboard(bool default_value) {
   bool allowed = false;
+  WebFrame* frame = render_frame()->GetWebFrame();
   Send(new ChromeViewHostMsg_CanTriggerClipboardWrite(
       GURL(frame->document().securityOrigin().toString()), &allowed));
   return allowed;
 }
 
-bool ContentSettingsObserver::allowWebComponents(WebFrame* frame,
-                                                 bool defaultValue) {
-  if (defaultValue)
+bool ContentSettingsObserver::allowWebComponents(bool default_value) {
+  if (default_value)
     return true;
 
+  WebFrame* frame = render_frame()->GetWebFrame();
   WebSecurityOrigin origin = frame->document().securityOrigin();
   if (EqualsASCII(origin.protocol(), content::kChromeUIScheme))
     return true;
 
   if (const extensions::Extension* extension = GetExtension(origin)) {
     if (extension->HasAPIPermission(APIPermission::kExperimental))
       return true;
   }
 
   return false;
 }
 
-bool ContentSettingsObserver::allowMutationEvents(WebFrame* frame,
-                                                  bool default_value) {
+bool ContentSettingsObserver::allowMutationEvents(bool default_value) {
+  WebFrame* frame = render_frame()->GetWebFrame();
   WebSecurityOrigin origin = frame->document().securityOrigin();
   const extensions::Extension* extension = GetExtension(origin);
   if (extension && extension->is_platform_app())
     return false;
   return default_value;
 }
 
-bool ContentSettingsObserver::allowPushState(WebFrame* frame) {
+bool ContentSettingsObserver::allowPushState() {
+  WebFrame* frame = render_frame()->GetWebFrame();
   WebSecurityOrigin origin = frame->document().securityOrigin();
   const extensions::Extension* extension = GetExtension(origin);
   return !extension || !extension->is_platform_app();
 }
 
 static void SendInsecureContentSignal(int signal) {
   UMA_HISTOGRAM_ENUMERATION("SSL.InsecureContent", signal,
                             INSECURE_CONTENT_NUM_EVENTS);
 }
 
 bool ContentSettingsObserver::allowDisplayingInsecureContent(
-    blink::WebFrame* frame,
     bool allowed_per_settings,
     const blink::WebSecurityOrigin& origin,
     const blink::WebURL& resource_url) {
   SendInsecureContentSignal(INSECURE_CONTENT_DISPLAY);
 
   std::string origin_host(origin.host().utf8());
+  WebFrame* frame = render_frame()->GetWebFrame();
   GURL frame_gurl(frame->document().url());
   if (IsHostInDomain(origin_host, kGoogleDotCom)) {
     SendInsecureContentSignal(INSECURE_CONTENT_DISPLAY_HOST_GOOGLE);
     if (StartsWithASCII(frame_gurl.path(), kGoogleSupportPathPrefix, false)) {
       SendInsecureContentSignal(INSECURE_CONTENT_DISPLAY_HOST_GOOGLE_SUPPORT);
     } else if (StartsWithASCII(frame_gurl.path(),
                                kGoogleIntlPathPrefix,
                                false)) {
       SendInsecureContentSignal(INSECURE_CONTENT_DISPLAY_HOST_GOOGLE_INTL);
     }
@@ skipping 29 matching lines @@
 
   if (allowed_per_settings || allow_displaying_insecure_content_)
     return true;
 
   Send(new ChromeViewHostMsg_DidBlockDisplayingInsecureContent(routing_id()));
 
   return false;
 }
 
 bool ContentSettingsObserver::allowRunningInsecureContent(
-    blink::WebFrame* frame,
     bool allowed_per_settings,
     const blink::WebSecurityOrigin& origin,
     const blink::WebURL& resource_url) {
   std::string origin_host(origin.host().utf8());
+  WebFrame* frame = render_frame()->GetWebFrame();
   GURL frame_gurl(frame->document().url());
   DCHECK_EQ(frame_gurl.host(), origin_host);
 
   bool is_google = IsHostInDomain(origin_host, kGoogleDotCom);
   if (is_google) {
     SendInsecureContentSignal(INSECURE_CONTENT_RUN_HOST_GOOGLE);
     if (StartsWithASCII(frame_gurl.path(), kGoogleSupportPathPrefix, false)) {
       SendInsecureContentSignal(INSECURE_CONTENT_RUN_HOST_GOOGLE_SUPPORT);
     } else if (StartsWithASCII(frame_gurl.path(),
                                kGoogleIntlPathPrefix,
@@ skipping 40 matching lines @@
     SendInsecureContentSignal(INSECURE_CONTENT_RUN_SWF);
 
   if (!allow_running_insecure_content_ && !allowed_per_settings) {
     DidBlockContentType(CONTENT_SETTINGS_TYPE_MIXEDSCRIPT);
     return false;
   }
 
   return true;
 }
 
-void ContentSettingsObserver::didNotAllowPlugins(WebFrame* frame) {
+void ContentSettingsObserver::didNotAllowPlugins() {
   DidBlockContentType(CONTENT_SETTINGS_TYPE_PLUGINS);
 }
 
-void ContentSettingsObserver::didNotAllowScript(WebFrame* frame) {
+void ContentSettingsObserver::didNotAllowScript() {
   DidBlockContentType(CONTENT_SETTINGS_TYPE_JAVASCRIPT);
 }
 
 bool ContentSettingsObserver::AreNPAPIPluginsBlocked() const {
   return npapi_plugins_blocked_;
 }
 
 void ContentSettingsObserver::OnLoadBlockedPlugins(
     const std::string& identifier) {
   temporarily_allowed_plugins_.insert(identifier);
@@ skipping 82 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(), content::kFileScheme)) {
     return document_url.SchemeIs(content::kFileScheme) &&
            document_url.ExtractFileName().empty();
   }
 
   return false;
 }