Move weburlresponse_extradata_impl.* from webkit/ to content/.

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 "extensions/common/constants.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "extensions/renderer/dispatcher.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"
 #include "third_party/WebKit/public/web/WebFrame.h"
 #include "third_party/WebKit/public/web/WebFrameClient.h"
 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/web/WebView.h"
-#include "webkit/child/weburlresponse_extradata_impl.h"
 
 #if defined(ENABLE_EXTENSIONS)
 #include "chrome/common/extensions/chrome_extension_messages.h"
 #endif
 
 using blink::WebDataSource;
 using blink::WebDocument;
 using blink::WebFrame;
 using blink::WebPermissionCallbacks;
 using blink::WebSecurityOrigin;
@@ skipping 257 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;
 
-    WebFrame* frame = render_frame()->GetWebFrame();
-    if (IsWhitelistedForContentSettings(frame))
+    if (IsWhitelistedForContentSettings(render_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;
+      allow =
+          GetContentSettingFromRules(content_setting_rules_->image_rules,
+                                     render_frame()->GetWebFrame(),
+                                     secondary_url) != CONTENT_SETTING_BLOCK;
     }
   }
   if (!allow)
     DidBlockContentType(CONTENT_SETTINGS_TYPE_IMAGES);
   return allow;
 }
 
 bool ContentSettingsObserver::allowIndexedDB(const WebString& name,
                                              const WebSecurityOrigin& origin) {
   WebFrame* frame = render_frame()->GetWebFrame();
@@ skipping 29 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(frame);
+  allow = allow || IsWhitelistedForContentSettings(render_frame());
 
   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;
-  WebFrame* frame = render_frame()->GetWebFrame();
   if (content_setting_rules_) {
-    ContentSetting setting = GetContentSettingFromRules(
-        content_setting_rules_->script_rules,
-        frame,
-        GURL(script_url));
+    ContentSetting setting =
+        GetContentSettingFromRules(content_setting_rules_->script_rules,
+                                   render_frame()->GetWebFrame(),
+                                   GURL(script_url));
     allow = setting != CONTENT_SETTING_BLOCK;
   }
-  return allow || IsWhitelistedForContentSettings(frame);
+  return allow || IsWhitelistedForContentSettings(render_frame());
 }
 
 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 262 matching lines @@
   if (!EqualsASCII(origin.protocol(), extensions::kExtensionScheme))
     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);
 }
 
-bool ContentSettingsObserver::IsWhitelistedForContentSettings(WebFrame* frame) {
+bool ContentSettingsObserver::IsWhitelistedForContentSettings(
+    content::RenderFrame* frame) {
   // Whitelist Instant processes.
   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kInstantProcess))
     return true;
 
   // Whitelist ftp directory listings, as they require JavaScript to function
   // properly.
-  webkit_glue::WebURLResponseExtraDataImpl* extra_data =
-      static_cast<webkit_glue::WebURLResponseExtraDataImpl*>(
-          frame->dataSource()->response().extraData());
-  if (extra_data && extra_data->is_ftp_directory_listing())
+  if (frame->IsFTPDirectoryListing())
     return true;
-  return IsWhitelistedForContentSettings(frame->document().securityOrigin(),
-                                         frame->document().url());
+
+  WebFrame* web_frame = 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;
 
   if (origin.isUnique())
     return false;  // Uninitialized document?
@@ skipping 14 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;
 }