An implementation of chrome.socket.secure().

chrome/browser/extensions/api/api_resource_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_API_API_RESOURCE_MANAGER_H_
 #define CHROME_BROWSER_EXTENSIONS_API_API_RESOURCE_MANAGER_H_
 
 #include <map>
 
 #include "base/containers/hash_tables.h"
@@ skipping 115 matching lines @@
   }
 
   T* Get(const std::string& extension_id, int api_resource_id) {
     return data_->Get(extension_id, api_resource_id);
   }
 
   base::hash_set<int>* GetResourceIds(const std::string& extension_id) {
     return data_->GetResourceIds(extension_id);
   }
 
+  bool Set(const std::string& extension_id, int api_resource_id, T* resource) {
+    return data_->Set(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: {
         std::string id =
             content::Details<extensions::UnloadedExtensionInfo>(details)->
                 extension->id();
@@ skipping 61 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(content::BrowserThread::CurrentlyOn(thread_id_));
       return GetOwnedResource(extension_id, api_resource_id);
     }
 
+    bool Set(const std::string& extension_id, int api_resource_id,
+             T* api_resource) {
+      DCHECK(content::BrowserThread::CurrentlyOn(thread_id_));
+      linked_ptr<T> old_resource_ptr = api_resource_map_[api_resource_id];

[Ryan Sleevi, 2013/11/25 17:30:13]

Is there a reason to take a copy of this linked_ptr?

Seems like you could just do

T* resource = api_resource_map_[api_resource_id].get();
if (resource && extension_id == resource->owner_extension_id()) {
  api_resource_map_[api_resource_id].reset(api_resource);
  return true;
}
return false;

Note that "else after return" is discouraged by the Chromium style guide. -
http://www.chromium.org/developers/coding-style#Code_Formatting

Finally, is either code correct? It seems it should be

if (resource && extension_id != resource->owner_extension_id())
    return false;
api_resource_map_[api_resource_id].reset(api_resource);
return true;

This covers the case where an API resource ID is not yet assigned (and assigns
it), where the API resource ID is assigned (and owned by the extension), and
when the API resource ID is assigned and NOT owned by the extension (and fails
appropriately)

+      T* old_resource = old_resource_ptr.get();
+      if (old_resource && extension_id == old_resource->owner_extension_id()) {
+        api_resource_map_[api_resource_id] = linked_ptr<T>(api_resource);
+        return true;
+      } else {
+        return false;
+      }
+    }
+
+
     base::hash_set<int>* GetResourceIds(const std::string& extension_id) {
       DCHECK(content::BrowserThread::CurrentlyOn(thread_id_));
       return GetOwnedResourceIds(extension_id);
     }
 
     void InitiateExtensionUnloadedCleanup(const std::string& extension_id) {
       content::BrowserThread::PostTask(thread_id_, FROM_HERE,
           base::Bind(&ApiResourceData::CleanupResourcesFromUnloadedExtension,
                      this, extension_id));
     }
@@ skipping 98 matching lines @@
   };
 
   content::BrowserThread::ID thread_id_;
   content::NotificationRegistrar registrar_;
   scoped_refptr<ApiResourceData> data_;
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_API_RESOURCE_MANAGER_H_