Additional methods for chrome.logPrivate API

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 18 matching lines @@
 class BluetoothSocketEventDispatcher;
 }
 
 namespace core_api {
 class SerialEventDispatcher;
 class TCPServerSocketEventDispatcher;
 class TCPSocketEventDispatcher;
 class UDPSocketEventDispatcher;
 }
 
+template <typename T>
+struct NamedThreadTraits {
+  static bool IsCalledOnValidThread() {
+    return content::BrowserThread::CurrentlyOn(T::kThreadId);
+  }
+
+  static bool IsMessageLoopValid() {
+    return content::BrowserThread::IsMessageLoopValid(T::kThreadId);
+  }
+
+  static scoped_refptr<base::SequencedTaskRunner> GetSequencedTaskRunner() {
+    return content::BrowserThread::GetMessageLoopProxyForThread(T::kThreadId);
+  }
+};
+
+template <typename T>
+struct TestThreadTraits {
+  static bool IsCalledOnValidThread() {
+    return content::BrowserThread::CurrentlyOn(thread_id_);
+  }
+
+  static bool IsMessageLoopValid() {
+    return content::BrowserThread::IsMessageLoopValid(thread_id_);
+  }
+
+  static scoped_refptr<base::SequencedTaskRunner> GetSequencedTaskRunner() {
+    return content::BrowserThread::GetMessageLoopProxyForThread(thread_id_);
+  }
+
+  static content::BrowserThread::ID thread_id_;
+};
+
+template <typename T>
+content::BrowserThread::ID TestThreadTraits<T>::thread_id_ =
+    content::BrowserThread::IO;
+
 // An ApiResourceManager manages the lifetime of a set of resources that
-// ApiFunctions use. Examples are sockets or USB connections.
+// that live on named threads (i.e. BrowserThread::IO) which ApiFunctions use.
+// Examples of such resources are sockets or USB connections.
 //
 // Users of this class should define kThreadId to be the thread that
 // ApiResourceManager to works on. The default is defined in ApiResource.
 // The user must also define a static const char* service_name() that returns
 // the name of the service, and in order for ApiResourceManager to use
 // service_name() friend this class.
 //
 // In the cc file the user must define a GetFactoryInstance() and manage their
 // own instances (typically using LazyInstance or Singleton).
 //
@@ skipping 14 matching lines @@
 // static base::LazyInstance<BrowserContextKeyedAPIFactory<
 //     ApiResourceManager<Resource> > >
 //         g_factory = LAZY_INSTANCE_INITIALIZER;
 //
 //
 // template <>
 // BrowserContextKeyedAPIFactory<ApiResourceManager<Resource> >*
 // ApiResourceManager<Resource>::GetFactoryInstance() {
 //   return g_factory.Pointer();
 // }
-template <class T>
+template <class T, typename ThreadingTraits = NamedThreadTraits<T> >
 class ApiResourceManager : public BrowserContextKeyedAPI,
                            public base::NonThreadSafe,
                            public content::NotificationObserver {
  public:
   explicit ApiResourceManager(content::BrowserContext* context)
-      : thread_id_(T::kThreadId), data_(new ApiResourceData(thread_id_)) {
+      : data_(new ApiResourceData()) {
     registrar_.Add(this,
                    chrome::NOTIFICATION_EXTENSION_UNLOADED_DEPRECATED,
                    content::NotificationService::AllSources());
     registrar_.Add(this,
                    chrome::NOTIFICATION_EXTENSION_HOST_DESTROYED,
                    content::NotificationService::AllSources());
   }
-
   // For Testing.
-  static ApiResourceManager<T>* CreateApiResourceManagerForTest(
-      content::BrowserContext* context,
-      content::BrowserThread::ID thread_id) {
-    ApiResourceManager* manager = new ApiResourceManager<T>(context);
-    manager->thread_id_ = thread_id;
-    manager->data_ = new ApiResourceData(thread_id);
+  static ApiResourceManager<T, TestThreadTraits<T> >*
+  CreateApiResourceManagerForTest(content::BrowserContext* context,
+                                  content::BrowserThread::ID thread_id) {
+    TestThreadTraits<T>::thread_id_ = thread_id;
+    ApiResourceManager<T, TestThreadTraits<T> >* manager =
+        new ApiResourceManager<T, TestThreadTraits<T> >(context);
     return manager;
   }
 
   virtual ~ApiResourceManager() {
     DCHECK(CalledOnValidThread());
-    DCHECK(content::BrowserThread::IsMessageLoopValid(thread_id_))
+    DCHECK(ThreadingTraits::IsMessageLoopValid())
         << "A unit test is using an ApiResourceManager but didn't provide "
            "the thread message loop needed for that kind of resource. "
            "Please ensure that the appropriate message loop is operational.";
 
     data_->InititateCleanup();
   }
 
-  // BrowserContextKeyedAPI implementation.
-  static BrowserContextKeyedAPIFactory<ApiResourceManager<T> >*
-      GetFactoryInstance();
-
-  // Convenience method to get the ApiResourceManager for a profile.
-  static ApiResourceManager<T>* Get(content::BrowserContext* context) {
-    return BrowserContextKeyedAPIFactory<ApiResourceManager<T> >::Get(context);
-  }
-
   // Takes ownership.
   int Add(T* api_resource) { return data_->Add(api_resource); }
 
   void Remove(const std::string& extension_id, int api_resource_id) {
     data_->Remove(extension_id, api_resource_id);
   }
 
   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);
   }
 
+  // BrowserContextKeyedAPI implementation.
+  static BrowserContextKeyedAPIFactory<ApiResourceManager<T> >*
+      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(); }
+
  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 12 matching lines @@
   // we could avoid maintaining a friends list here.
   friend class BluetoothAPI;
   friend class api::BluetoothSocketApiFunction;
   friend class api::BluetoothSocketEventDispatcher;
   friend class core_api::SerialEventDispatcher;
   friend class core_api::TCPServerSocketEventDispatcher;
   friend class core_api::TCPSocketEventDispatcher;
   friend class core_api::UDPSocketEventDispatcher;
   friend class BrowserContextKeyedAPIFactory<ApiResourceManager<T> >;
 
-  // BrowserContextKeyedAPI implementation.
-  static const char* service_name() { return T::service_name(); }
-
   static const bool kServiceHasOwnInstanceInIncognito = true;
   static const bool kServiceIsNULLWhileTesting = true;
 
   // ApiResourceData class handles resource bookkeeping on a thread
   // where resource lifetime is handled.
   class ApiResourceData : public base::RefCountedThreadSafe<ApiResourceData> {
    public:
     typedef std::map<int, linked_ptr<T> > ApiResourceMap;
     // Lookup map from extension id's to allocated resource id's.
     typedef std::map<std::string, base::hash_set<int> > ExtensionToResourceMap;
 
-    explicit ApiResourceData(const content::BrowserThread::ID thread_id)
-        : next_id_(1), thread_id_(thread_id) {}
+    ApiResourceData() : next_id_(1) {}
 
     int Add(T* api_resource) {
-      DCHECK_CURRENTLY_ON(thread_id_);
+      DCHECK(ThreadingTraits::IsCalledOnValidThread());
       int id = GenerateId();
       if (id > 0) {
         linked_ptr<T> resource_ptr(api_resource);
         api_resource_map_[id] = resource_ptr;
 
         const std::string& extension_id = api_resource->owner_extension_id();
         if (extension_resource_map_.find(extension_id) ==
             extension_resource_map_.end()) {
           extension_resource_map_[extension_id] = base::hash_set<int>();
         }
         extension_resource_map_[extension_id].insert(id);
 
         return id;
       }
       return 0;
     }
 
     void Remove(const std::string& extension_id, int api_resource_id) {
-      DCHECK_CURRENTLY_ON(thread_id_);
+      DCHECK(ThreadingTraits::IsCalledOnValidThread());
       if (GetOwnedResource(extension_id, api_resource_id) != NULL) {
         DCHECK(extension_resource_map_.find(extension_id) !=
                extension_resource_map_.end());
         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_CURRENTLY_ON(thread_id_);
+      DCHECK(ThreadingTraits::IsCalledOnValidThread());
       return GetOwnedResource(extension_id, api_resource_id);
     }
 
     base::hash_set<int>* GetResourceIds(const std::string& extension_id) {
-      DCHECK_CURRENTLY_ON(thread_id_);
+      DCHECK(ThreadingTraits::IsCalledOnValidThread());
       return GetOwnedResourceIds(extension_id);
     }
 
     void InitiateExtensionUnloadedCleanup(const std::string& extension_id) {
-      if (content::BrowserThread::CurrentlyOn(thread_id_)) {
+      if (ThreadingTraits::IsCalledOnValidThread()) {
         CleanupResourcesFromUnloadedExtension(extension_id);
       } else {
-        content::BrowserThread::PostTask(
-            thread_id_,
+        ThreadingTraits::GetSequencedTaskRunner()->PostTask(
             FROM_HERE,
             base::Bind(&ApiResourceData::CleanupResourcesFromUnloadedExtension,
                        this,
                        extension_id));
       }
     }
 
     void InitiateExtensionSuspendedCleanup(const std::string& extension_id) {
-      if (content::BrowserThread::CurrentlyOn(thread_id_)) {
+      if (ThreadingTraits::IsCalledOnValidThread()) {
         CleanupResourcesFromSuspendedExtension(extension_id);
       } else {
-        content::BrowserThread::PostTask(
-            thread_id_,
+        ThreadingTraits::GetSequencedTaskRunner()->PostTask(
             FROM_HERE,
             base::Bind(&ApiResourceData::CleanupResourcesFromSuspendedExtension,
                        this,
                        extension_id));
       }
     }
 
     void InititateCleanup() {
-      if (content::BrowserThread::CurrentlyOn(thread_id_)) {
+      if (ThreadingTraits::IsCalledOnValidThread()) {
         Cleanup();
       } else {
-        content::BrowserThread::PostTask(
-            thread_id_, FROM_HERE, base::Bind(&ApiResourceData::Cleanup, this));
+        ThreadingTraits::GetSequencedTaskRunner()->PostTask(
+            FROM_HERE, base::Bind(&ApiResourceData::Cleanup, this));
       }
     }
 
    private:
     friend class base::RefCountedThreadSafe<ApiResourceData>;
 
     virtual ~ApiResourceData() {}
 
     T* GetOwnedResource(const std::string& extension_id, int api_resource_id) {
       linked_ptr<T> ptr = api_resource_map_[api_resource_id];
       T* resource = ptr.get();
       if (resource && extension_id == resource->owner_extension_id())
         return resource;
       return NULL;
     }
 
     base::hash_set<int>* GetOwnedResourceIds(const std::string& extension_id) {
-      DCHECK_CURRENTLY_ON(thread_id_);
+      DCHECK(ThreadingTraits::IsCalledOnValidThread());
       if (extension_resource_map_.find(extension_id) ==
           extension_resource_map_.end())
         return NULL;
 
       return &extension_resource_map_[extension_id];
     }
 
     void CleanupResourcesFromUnloadedExtension(
         const std::string& extension_id) {
       CleanupResourcesFromExtension(extension_id, true);
     }
 
     void CleanupResourcesFromSuspendedExtension(
         const std::string& extension_id) {
       CleanupResourcesFromExtension(extension_id, false);
     }
 
     void CleanupResourcesFromExtension(const std::string& extension_id,
                                        bool remove_all) {
-      DCHECK_CURRENTLY_ON(thread_id_);
+      DCHECK(ThreadingTraits::IsCalledOnValidThread());
 
       if (extension_resource_map_.find(extension_id) ==
           extension_resource_map_.end()) {
         return;
       }
 
       // Remove all resources, or the non persistent ones only if |remove_all|
       // is false.
       base::hash_set<int>& resource_ids = extension_resource_map_[extension_id];
       for (base::hash_set<int>::iterator it = resource_ids.begin();
@@ skipping 15 matching lines @@
         }
       }  // end for
 
       // Remove extension entry if we removed all its resources.
       if (resource_ids.size() == 0) {
         extension_resource_map_.erase(extension_id);
       }
     }
 
     void Cleanup() {
-      DCHECK_CURRENTLY_ON(thread_id_);
+      DCHECK(ThreadingTraits::IsCalledOnValidThread());
 
       api_resource_map_.clear();
       extension_resource_map_.clear();
     }
 
     int GenerateId() { return next_id_++; }
 
     int next_id_;
-    const content::BrowserThread::ID thread_id_;
     ApiResourceMap api_resource_map_;
     ExtensionToResourceMap extension_resource_map_;
   };
 
-  content::BrowserThread::ID thread_id_;
   content::NotificationRegistrar registrar_;
   scoped_refptr<ApiResourceData> data_;
 };
 
+// With WorkerPoolThreadTraits, ApiResourceManager can be used to manage the
+// lifetime of a set of resources that live on sequenced task runner threads
+// which ApiFunctions use. Examples of such resources are temporary file
+// resources produced by certain API calls.
+//
+// Instead of kThreadId. classes used for tracking identifying such resources

[Ken Rockot(use gerrit already), 2014/07/22 15:33:59]

nit: -identifying? (or +and)

[zel, 2014/07/22 22:45:03]

Done.

+// should define kSequenceToken and kShutdownBehavior to identify sequence task
+// runner for ApiResourceManager to work on and how pending tasks should behave
+// on shutdown.
+// The user must also define a static const char* service_name() that returns
+// the name of the service, and in order for ApiWorkerPoolResourceManager to use
+// service_name() friend this class.
+//
+// In the cc file the user must define a GetFactoryInstance() and manage their
+// own instances (typically using LazyInstance or Singleton).
+//
+// E.g.:
+//
+// class PoolResource {
+//  public:
+//   static const char kSequenceToken[] = "temp_files";
+//   static const base::SequencedWorkerPool::WorkerShutdown kShutdownBehavior =
+//       base::SequencedWorkerPool::BLOCK_SHUTDOWN;
+//  private:
+//   friend class ApiResourceManager<WorkerPoolResource,
+//                                   WorkerPoolThreadTraits>;
+//   static const char* service_name() {
+//     return "TempFilesResourceManager";
+//    }
+// };
+//
+// In the cc file:
+//
+// static base::LazyInstance<BrowserContextKeyedAPIFactory<
+//     ApiResourceManager<Resource, WorkerPoolThreadTraits> > >
+//         g_factory = LAZY_INSTANCE_INITIALIZER;
+//
+//
+// template <>
+// BrowserContextKeyedAPIFactory<ApiResourceManager<WorkerPoolResource> >*
+// ApiResourceManager<WorkerPoolPoolResource,
+//                    WorkerPoolThreadTraits>::GetFactoryInstance() {
+//   return g_factory.Pointer();
+// }
+template <typename T>
+struct WorkerPoolThreadTraits {
+  static bool IsCalledOnValidThread() {
+    return content::BrowserThread::GetBlockingPool()
+        ->IsRunningSequenceOnCurrentThread(
+            content::BrowserThread::GetBlockingPool()->GetNamedSequenceToken(
+                T::kSequenceToken));
+  }
+
+  static bool IsMessageLoopValid() {
+    return content::BrowserThread::GetBlockingPool() != NULL;
+  }
+
+  static scoped_refptr<base::SequencedTaskRunner> GetSequencedTaskRunner() {
+    return content::BrowserThread::GetBlockingPool()
+        ->GetSequencedTaskRunnerWithShutdownBehavior(
+            content::BrowserThread::GetBlockingPool()->GetNamedSequenceToken(
+                T::kSequenceToken),
+            T::kShutdownBehavior);
+  }
+};
+
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_API_API_RESOURCE_MANAGER_H_