Remove call to IsRunningSequenceOnCurrentThread() from api_resource_manager.h.

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 <memory>
 
 #include "base/containers/hash_tables.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/scoped_observer.h"
+#include "base/sequence_checker.h"
 #include "base/threading/non_thread_safe.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/browser_context_keyed_api_factory.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_registry_observer.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/browser/process_manager_observer.h"
 #include "extensions/common/extension.h"
 
 namespace extensions {
 class CastChannelAsyncApiFunction;
 
 namespace api {
 class BluetoothSocketApiFunction;
 class BluetoothSocketEventDispatcher;
 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::GetTaskRunnerForThread(T::kThreadId);
   }
 };
 
 // An ApiResourceManager manages the lifetime of a set of resources that
@@ skipping 125 matching lines @@
   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, std::unique_ptr<T>> ApiResourceMap;
     // Lookup map from extension id's to allocated resource id's.
     typedef std::map<std::string, base::hash_set<int> > ExtensionToResourceMap;
 
-    ApiResourceData() : next_id_(1) {}
+    ApiResourceData() : next_id_(1) { sequence_checker_.DetachFromSequence(); }
 
     // TODO(lazyboy): Pass unique_ptr<T> instead of T*.
     int Add(T* api_resource) {
-      DCHECK(ThreadingTraits::IsCalledOnValidThread());
+      DCHECK(sequence_checker_.CalledOnValidSequence());
       int id = GenerateId();
       if (id > 0) {
         api_resource_map_[id] = base::WrapUnique<T>(api_resource);
 
         const std::string& extension_id = api_resource->owner_extension_id();
         ExtensionToResourceMap::iterator it =
             extension_resource_map_.find(extension_id);
         if (it == extension_resource_map_.end()) {
           it = extension_resource_map_.insert(
               std::make_pair(extension_id, base::hash_set<int>())).first;
         }
         it->second.insert(id);
         return id;
       }
       return 0;
     }
 
     void Remove(const std::string& extension_id, int api_resource_id) {
-      DCHECK(ThreadingTraits::IsCalledOnValidThread());
+      DCHECK(sequence_checker_.CalledOnValidSequence());
       if (GetOwnedResource(extension_id, api_resource_id)) {
         ExtensionToResourceMap::iterator it =
             extension_resource_map_.find(extension_id);
         it->second.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());
+      DCHECK(sequence_checker_.CalledOnValidSequence());
       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());
+      DCHECK(sequence_checker_.CalledOnValidSequence());
       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] = base::WrapUnique<T>(api_resource);
         return true;
       }
       return false;
     }
 
     base::hash_set<int>* GetResourceIds(const std::string& extension_id) {
-      DCHECK(ThreadingTraits::IsCalledOnValidThread());
+      DCHECK(sequence_checker_.CalledOnValidSequence());
       return GetOwnedResourceIds(extension_id);
     }
 
     void InitiateExtensionUnloadedCleanup(const std::string& extension_id) {
-      if (ThreadingTraits::IsCalledOnValidThread()) {
-        CleanupResourcesFromUnloadedExtension(extension_id);
-      } else {
         ThreadingTraits::GetSequencedTaskRunner()->PostTask(
             FROM_HERE,
             base::Bind(&ApiResourceData::CleanupResourcesFromUnloadedExtension,
                        this,
                        extension_id));
-      }
     }
 
     void InitiateExtensionSuspendedCleanup(const std::string& extension_id) {
-      if (ThreadingTraits::IsCalledOnValidThread()) {
-        CleanupResourcesFromSuspendedExtension(extension_id);
-      } else {
         ThreadingTraits::GetSequencedTaskRunner()->PostTask(
             FROM_HERE,
             base::Bind(&ApiResourceData::CleanupResourcesFromSuspendedExtension,
                        this,
                        extension_id));
-      }
     }
 
     void InititateCleanup() {
-      if (ThreadingTraits::IsCalledOnValidThread()) {
-        Cleanup();
-      } else {
         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) {
       const std::unique_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(ThreadingTraits::IsCalledOnValidThread());
+      DCHECK(sequence_checker_.CalledOnValidSequence());
       ExtensionToResourceMap::iterator it =
           extension_resource_map_.find(extension_id);
       if (it == extension_resource_map_.end())
         return NULL;
       return &(it->second);
     }
 
     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(ThreadingTraits::IsCalledOnValidThread());
+      DCHECK(sequence_checker_.CalledOnValidSequence());
 
       ExtensionToResourceMap::iterator it =
           extension_resource_map_.find(extension_id);
       if (it == 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 = it->second;
       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(ThreadingTraits::IsCalledOnValidThread());
+      DCHECK(sequence_checker_.CalledOnValidSequence());
 
       api_resource_map_.clear();
       extension_resource_map_.clear();
     }
 
     int GenerateId() { return next_id_++; }
 
     int next_id_;
     ApiResourceMap api_resource_map_;
     ExtensionToResourceMap extension_resource_map_;
+    base::SequenceChecker sequence_checker_;
   };
 
   content::NotificationRegistrar registrar_;
   scoped_refptr<ApiResourceData> data_;
 
   ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver>
       extension_registry_observer_;
   ScopedObserver<ProcessManager, ProcessManagerObserver>
       process_manager_observer_;
 };
@@ skipping 37 matching lines @@
 //
 //
 // 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_