An implementation of chrome.socket.secure().

extensions/browser/api/api_resource_manager.h

 // Copyright 2014 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.
 
 #ifndef EXTENSIONS_BROWSER_API_API_RESOURCE_MANAGER_H_
 #define EXTENSIONS_BROWSER_API_API_RESOURCE_MANAGER_H_
 
 #include <map>
 
 #include "base/containers/hash_tables.h"
@@ skipping 152 matching lines @@
       GetFactoryInstance();
 
   // Convenience method to get the ApiResourceManager for a profile.
   static ApiResourceManager<T>* Get(content::BrowserContext* context) {
     return BrowserContextKeyedAPIFactory<ApiResourceManager<T> >::Get(context);
   }
 
   // BrowserContextKeyedAPI implementation.
   static const char* service_name() { return T::service_name(); }
 
+  // Change the resource mapped to this |extension_id| at this
+  // |api_resource_id| to |resource|. Returns true and succeeds unless
+  // |api_resource_id| does not already identify a resource held by
+  // |extension_id|.
+  bool Replace(const std::string& extension_id,
+               int api_resource_id,
+               T* resource) {
+    return data_->Replace(extension_id, api_resource_id, resource);
+  }
+
  protected:
   // content::NotificationObserver:
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE {
     switch (type) {
       case chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED: {
         std::string id = content::Details<extensions::UnloadedExtensionInfo>(
                              details)->extension->id();
         data_->InitiateExtensionUnloadedCleanup(id);
@@ skipping 59 matching lines @@
         extension_resource_map_[extension_id].erase(api_resource_id);
         api_resource_map_.erase(api_resource_id);
       }
     }
 
     T* Get(const std::string& extension_id, int api_resource_id) {
       DCHECK(ThreadingTraits::IsCalledOnValidThread());
       return GetOwnedResource(extension_id, api_resource_id);
     }
 
+    // Change the resource mapped to this |extension_id| at this
+    // |api_resource_id| to |resource|. Returns true and succeeds unless
+    // |api_resource_id| does not already identify a resource held by
+    // |extension_id|.
+    bool Replace(const std::string& extension_id,
+                 int api_resource_id,
+                 T* api_resource) {
+      DCHECK(ThreadingTraits::IsCalledOnValidThread());
+      T* old_resource = api_resource_map_[api_resource_id].get();
+      if (old_resource && extension_id == old_resource->owner_extension_id()) {
+        api_resource_map_[api_resource_id] = linked_ptr<T>(api_resource);
+        return true;
+      }
+      return false;
+    }
+
     base::hash_set<int>* GetResourceIds(const std::string& extension_id) {
       DCHECK(ThreadingTraits::IsCalledOnValidThread());
       return GetOwnedResourceIds(extension_id);
     }
 
     void InitiateExtensionUnloadedCleanup(const std::string& extension_id) {
       if (ThreadingTraits::IsCalledOnValidThread()) {
         CleanupResourcesFromUnloadedExtension(extension_id);
       } else {
         ThreadingTraits::GetSequencedTaskRunner()->PostTask(
@@ skipping 174 matching lines @@
         ->GetSequencedTaskRunnerWithShutdownBehavior(
             content::BrowserThread::GetBlockingPool()->GetNamedSequenceToken(
                 T::kSequenceToken),
             T::kShutdownBehavior);
   }
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_API_API_RESOURCE_MANAGER_H_