PPAPI: Introduce concept of ResourceHosts "pinning" each other

ppapi/host/ppapi_host.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 "ppapi/host/ppapi_host.h"
 
 #include "base/logging.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/host/host_factory.h"
 #include "ppapi/host/host_message_context.h"
@@ skipping 26 matching lines @@
 
 PpapiHost::~PpapiHost() {
   // Delete these explicitly before destruction since then the host is still
   // technically alive in case one of the filters accesses us from the
   // destructor.
   instance_message_filters_.clear();
 
   // The resources may also want to use us in their destructors.
   resources_.clear();
   pending_resource_hosts_.clear();
+  // At this point, all hosts should have Unpinned anything they depend on in
+  // their destructors, so this map should be empty.
+  DCHECK(owner_to_owned_map_.empty()) << "A ResourceHost forgot to Unpin";
 }
 
 bool PpapiHost::Send(IPC::Message* msg) {
   return sender_->Send(msg);
 }
 
 bool PpapiHost::OnMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(PpapiHost, msg)
     IPC_MESSAGE_HANDLER(PpapiHostMsg_ResourceCall,
@@ skipping 100 matching lines @@
 
 void PpapiHost::AddHostFactoryFilter(scoped_ptr<HostFactory> filter) {
   host_factory_filters_.push_back(filter.release());
 }
 
 void PpapiHost::AddInstanceMessageFilter(
     scoped_ptr<InstanceMessageFilter> filter) {
   instance_message_filters_.push_back(filter.release());
 }
 
+ResourceHost* PpapiHost::GetResourceHost(PP_Resource resource) const {
+  ResourceMap::const_iterator found = resources_.find(resource);
+  return found == resources_.end() ? NULL : found->second.get();
+}
+
+void PpapiHost::PinHost(ResourceHost* owner_host, ResourceHost* owned_host) {
+  // Only allow a ResourceHost to be "owned" or be an "owner", but not both.
+  // This prevents graphs that are >1 level deep and also prevents cycles.
+  DCHECK(owner_to_owned_map_.count(owned_host) == 0)
+      << "A ResourceHost is not allowed to own and also be owned.";
+  linked_ptr<ResourceHost> owned_linked_ptr = RawToLinkedPtr(owned_host);
+  DCHECK(owned_linked_ptr.get());
+  DCHECK(owner_to_owned_map_[owner_host].count(owned_linked_ptr) == 0);
+  owner_to_owned_map_[owner_host][owned_linked_ptr]++;
+}
+
+void PpapiHost::UnpinHost(ResourceHost* owner_host, ResourceHost* owned_host) {
+  OwnerToOwnedHostMap::iterator iter = owner_to_owned_map_.find(owner_host);
+  DCHECK(iter != owner_to_owned_map_.end());
+  if (iter != owner_to_owned_map_.end()) {
+    linked_ptr<ResourceHost> owned_linked_ptr = RawToLinkedPtr(owned_host);
+    PinCountMap::iterator count_iter = iter->second.find(owned_linked_ptr);
+    if (--count_iter->second == 0)
+      iter->second.erase(count_iter);
+    if (iter->second.empty())
+      owner_to_owned_map_.erase(iter);
+  }
+}
+
 void PpapiHost::OnHostMsgResourceCall(
     const proxy::ResourceMessageCallParams& params,
     const IPC::Message& nested_msg) {
   TRACE_EVENT2("ppapi proxy", "PpapiHost::OnHostMsgResourceCall",
                "Class", IPC_MESSAGE_ID_CLASS(nested_msg.type()),
                "Line", IPC_MESSAGE_ID_LINE(nested_msg.type()));
   HostMessageContext context(params);
   HandleResourceCall(params, nested_msg, &context);
 }
 
@@ skipping 92 matching lines @@
   }
   // Invoking the HostResource destructor might result in looking up the
   // PP_Resource in resources_. std::map is not well specified as to whether the
   // element will be there or not. Therefore, we delay destruction of the
   // HostResource until after we've made sure the map no longer contains
   // |resource|.
   linked_ptr<ResourceHost> delete_at_end_of_scope(found->second);
   resources_.erase(found);
 }
 
-ResourceHost* PpapiHost::GetResourceHost(PP_Resource resource) const {
-  ResourceMap::const_iterator found = resources_.find(resource);
-  return found == resources_.end() ? NULL : found->second.get();
+linked_ptr<ResourceHost> PpapiHost::RawToLinkedPtr(ResourceHost* host) {
+  if (host->pp_resource()) {
+    // If it has a valid PP_Resource, it's not "pending" and therefore should
+    // be in resources_.
+    DCHECK(resources_.count(host->pp_resource()));
+    return resources_[host->pp_resource()];
+  } else {
+    // It's a pending host. This map should be small, so a linear search is OK.
+    PendingHostResourceMap::iterator iter = pending_resource_hosts_.begin();
+    for (; iter != pending_resource_hosts_.end(); ++iter) {
+      if (host == iter->second.get())
+        return iter->second;
+    }
+  }
+  NOTREACHED();
+  return linked_ptr<ResourceHost>();
 }
 
 }  // namespace host
 }  // namespace ppapi