Rename RendererSecurityPolicy and move it to browser\. No code change.

chrome/browser/child_process_security_policy.cc

 // Copyright (c) 2006-2008 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/browser/renderer_host/renderer_security_policy.h"
+#include "chrome/browser/child_process_security_policy.h"
 
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "chrome/common/url_constants.h"
 #include "googleurl/src/gurl.h"
 #include "net/url_request/url_request.h"
 
 // The SecurityState class is used to maintain per-renderer security state
 // information.
-class RendererSecurityPolicy::SecurityState {
+class ChildProcessSecurityPolicy::SecurityState {
  public:
   SecurityState() : has_dom_ui_bindings_(false) { }
   ~SecurityState() {
     scheme_policy_.clear();
   }
 
   // Grant permission to request URLs with the specified scheme.
   void GrantScheme(const std::string& scheme) {
     scheme_policy_[scheme] = true;
   }
@@ skipping 43 matching lines @@
   SchemeMap scheme_policy_;
 
   // The set of files the renderer is permited to upload to the web.
   FileSet uploadable_files_;
 
   bool has_dom_ui_bindings_;
 
   DISALLOW_COPY_AND_ASSIGN(SecurityState);
 };
 
-RendererSecurityPolicy::RendererSecurityPolicy() {
+ChildProcessSecurityPolicy::ChildProcessSecurityPolicy() {
   // We know about these schemes and believe them to be safe.
   RegisterWebSafeScheme(chrome::kHttpScheme);
   RegisterWebSafeScheme(chrome::kHttpsScheme);
   RegisterWebSafeScheme(chrome::kFtpScheme);
   RegisterWebSafeScheme(chrome::kDataScheme);
   RegisterWebSafeScheme("feed");
   RegisterWebSafeScheme("chrome-extension");
 
   // We know about the following psuedo schemes and treat them specially.
   RegisterPseudoScheme(chrome::kAboutScheme);
   RegisterPseudoScheme(chrome::kJavaScriptScheme);
   RegisterPseudoScheme(chrome::kViewSourceScheme);
 }
 
-RendererSecurityPolicy::~RendererSecurityPolicy() {
+ChildProcessSecurityPolicy::~ChildProcessSecurityPolicy() {
   web_safe_schemes_.clear();
   pseudo_schemes_.clear();
   STLDeleteContainerPairSecondPointers(security_state_.begin(),
                                        security_state_.end());
   security_state_.clear();
 }
 
 // static
-RendererSecurityPolicy* RendererSecurityPolicy::GetInstance() {
-  return Singleton<RendererSecurityPolicy>::get();
+ChildProcessSecurityPolicy* ChildProcessSecurityPolicy::GetInstance() {
+  return Singleton<ChildProcessSecurityPolicy>::get();
 }
 
-void RendererSecurityPolicy::Add(int renderer_id) {
+void ChildProcessSecurityPolicy::Add(int renderer_id) {
   AutoLock lock(lock_);
   if (security_state_.count(renderer_id) != 0) {
     NOTREACHED() << "Add renderers at most once.";
     return;
   }
 
   security_state_[renderer_id] = new SecurityState();
 }
 
-void RendererSecurityPolicy::Remove(int renderer_id) {
+void ChildProcessSecurityPolicy::Remove(int renderer_id) {
   AutoLock lock(lock_);
   if (security_state_.count(renderer_id) != 1) {
     NOTREACHED() << "Remove renderers at most once.";
     return;
   }
 
   delete security_state_[renderer_id];
   security_state_.erase(renderer_id);
 }
 
-void RendererSecurityPolicy::RegisterWebSafeScheme(const std::string& scheme) {
+void ChildProcessSecurityPolicy::RegisterWebSafeScheme(const std::string& scheme) {
   AutoLock lock(lock_);
   DCHECK(web_safe_schemes_.count(scheme) == 0) << "Add schemes at most once.";
   DCHECK(pseudo_schemes_.count(scheme) == 0) << "Web-safe implies not psuedo.";
 
   web_safe_schemes_.insert(scheme);
 }
 
-bool RendererSecurityPolicy::IsWebSafeScheme(const std::string& scheme) {
+bool ChildProcessSecurityPolicy::IsWebSafeScheme(const std::string& scheme) {
   AutoLock lock(lock_);
 
   return (web_safe_schemes_.find(scheme) != web_safe_schemes_.end());
 }
 
-void RendererSecurityPolicy::RegisterPseudoScheme(const std::string& scheme) {
+void ChildProcessSecurityPolicy::RegisterPseudoScheme(const std::string& scheme) {
   AutoLock lock(lock_);
   DCHECK(pseudo_schemes_.count(scheme) == 0) << "Add schemes at most once.";
   DCHECK(web_safe_schemes_.count(scheme) == 0) <<
       "Psuedo implies not web-safe.";
 
   pseudo_schemes_.insert(scheme);
 }
 
-bool RendererSecurityPolicy::IsPseudoScheme(const std::string& scheme) {
+bool ChildProcessSecurityPolicy::IsPseudoScheme(const std::string& scheme) {
   AutoLock lock(lock_);
 
   return (pseudo_schemes_.find(scheme) != pseudo_schemes_.end());
 }
 
-void RendererSecurityPolicy::GrantRequestURL(int renderer_id, const GURL& url) {
+void ChildProcessSecurityPolicy::GrantRequestURL(int renderer_id, const GURL& url) {
 
   if (!url.is_valid())
     return;  // Can't grant the capability to request invalid URLs.
 
   if (IsWebSafeScheme(url.scheme()))
     return;  // The scheme has already been white-listed for every renderer.
 
   if (IsPseudoScheme(url.scheme())) {
     // The view-source scheme is a special case of a pseudo URL that eventually
     // results in requesting its embedded URL.
@@ skipping 13 matching lines @@
     SecurityStateMap::iterator state = security_state_.find(renderer_id);
     if (state == security_state_.end())
       return;
 
     // If the renderer has been commanded to request a scheme, then we grant
     // it the capability to request URLs of that scheme.
     state->second->GrantScheme(url.scheme());
   }
 }
 
-void RendererSecurityPolicy::GrantUploadFile(int renderer_id,
+void ChildProcessSecurityPolicy::GrantUploadFile(int renderer_id,
                                              const FilePath& file) {
   AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(renderer_id);
   if (state == security_state_.end())
     return;
 
   state->second->GrantUploadFile(file);
 }
 
-void RendererSecurityPolicy::GrantInspectElement(int renderer_id) {
+void ChildProcessSecurityPolicy::GrantInspectElement(int renderer_id) {
   AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(renderer_id);
   if (state == security_state_.end())
     return;
 
   // The inspector is served from a chrome: URL.  In order to run the
   // inspector, the renderer needs to be able to load chrome: URLs.
   state->second->GrantScheme(chrome::kChromeUIScheme);
 }
 
-void RendererSecurityPolicy::GrantDOMUIBindings(int renderer_id) {
+void ChildProcessSecurityPolicy::GrantDOMUIBindings(int renderer_id) {
   AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(renderer_id);
   if (state == security_state_.end())
     return;
 
   state->second->GrantDOMUIBindings();
 
   // DOM UI bindings need the ability to request chrome: URLs.
   state->second->GrantScheme(chrome::kChromeUIScheme);
 
   // DOM UI pages can contain links to file:// URLs.
   state->second->GrantScheme(chrome::kFileScheme);
 }
 
-bool RendererSecurityPolicy::CanRequestURL(int renderer_id, const GURL& url) {
+bool ChildProcessSecurityPolicy::CanRequestURL(int renderer_id, const GURL& url) {
   if (!url.is_valid())
     return false;  // Can't request invalid URLs.
 
   if (IsWebSafeScheme(url.scheme()))
     return true;  // The scheme has been white-listed for every renderer.
 
   if (IsPseudoScheme(url.scheme())) {
     // There are a number of special cases for pseudo schemes.
 
     if (url.SchemeIs(chrome::kViewSourceScheme)) {
@@ skipping 20 matching lines @@
     SecurityStateMap::iterator state = security_state_.find(renderer_id);
     if (state == security_state_.end())
       return false;
 
     // Otherwise, we consult the renderer's security state to see if it is
     // allowed to request the URL.
     return state->second->CanRequestURL(url);
   }
 }
 
-bool RendererSecurityPolicy::CanUploadFile(int renderer_id,
+bool ChildProcessSecurityPolicy::CanUploadFile(int renderer_id,
                                            const FilePath& file) {
   AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(renderer_id);
   if (state == security_state_.end())
     return false;
 
   return state->second->CanUploadFile(file);
 }
 
-bool RendererSecurityPolicy::HasDOMUIBindings(int renderer_id) {
+bool ChildProcessSecurityPolicy::HasDOMUIBindings(int renderer_id) {
   AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(renderer_id);
   if (state == security_state_.end())
     return false;
 
   return state->second->has_dom_ui_bindings();
 }