Fix process reuse for dedicated processes when over process limit.

content/browser/child_process_security_policy_impl.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 "content/browser/child_process_security_policy_impl.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/command_line.h"
@@ skipping 250 matching lines @@
   bool CanAccessDataForOrigin(const GURL& site_url) {
     if (origin_lock_.is_empty())
       return true;
     return origin_lock_ == site_url;
   }
 
   void LockToOrigin(const GURL& gurl) {
     origin_lock_ = gurl;
   }
 
+  bool HasOriginLock() { return !origin_lock_.is_empty(); }
+
+  bool IsLockedToOrigin(const GURL& gurl) { return origin_lock_ == gurl; }
+
   bool has_web_ui_bindings() const {
     return enabled_bindings_ & BINDINGS_POLICY_WEB_UI;
   }
 
   bool can_read_raw_cookies() const {
     return can_read_raw_cookies_;
   }
 
   bool can_send_midi_sysex() const {
     return can_send_midi_sysex_;
@@ skipping 737 matching lines @@
 void ChildProcessSecurityPolicyImpl::LockToOrigin(int child_id,
                                                   const GURL& gurl) {
   // "gurl" can be currently empty in some cases, such as file://blah.
   DCHECK(SiteInstanceImpl::GetSiteForURL(NULL, gurl) == gurl);
   base::AutoLock lock(lock_);
   SecurityStateMap::iterator state = security_state_.find(child_id);
   DCHECK(state != security_state_.end());
   state->second->LockToOrigin(gurl);
 }
 
+bool ChildProcessSecurityPolicyImpl::HasOriginLock(int child_id) {
+  base::AutoLock lock(lock_);
+  SecurityStateMap::iterator state = security_state_.find(child_id);
+  if (state == security_state_.end())
+    return false;
+  return state->second->HasOriginLock();
+}
+
+bool ChildProcessSecurityPolicyImpl::IsLockedToOrigin(int child_id,
+                                                      const GURL& site_url) {
+  base::AutoLock lock(lock_);
+  SecurityStateMap::iterator state = security_state_.find(child_id);
+  if (state == security_state_.end())
+    return false;
+  return state->second->IsLockedToOrigin(site_url);
+}
+
 void ChildProcessSecurityPolicyImpl::GrantPermissionsForFileSystem(
     int child_id,
     const std::string& filesystem_id,
     int permission) {
   base::AutoLock lock(lock_);
 
   SecurityStateMap::iterator state = security_state_.find(child_id);
   if (state == security_state_.end())
     return;
   state->second->GrantPermissionsForFileSystem(filesystem_id, permission);
@@ skipping 50 matching lines @@
   }
 }
 
 bool ChildProcessSecurityPolicyImpl::IsIsolatedOrigin(
     const url::Origin& origin) {
   base::AutoLock lock(lock_);
   return isolated_origins_.find(origin) != isolated_origins_.end();
 }
 
 }  // namespace content