Deprecate NonThreadSafe in storage/browser/blob in favor of SequenceChecker.

storage/browser/blob/shareable_file_reference.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 "storage/browser/blob/shareable_file_reference.h"
 
 #include <map>
 #include <utility>
 
 #include "base/lazy_instance.h"
 #include "base/macros.h"
+#include "base/sequence_checker.h"
 #include "base/task_runner.h"
-#include "base/threading/non_thread_safe.h"
 
 namespace storage {
 
 namespace {
 
-// A shareable file map with enforcement of thread checker.
-class ShareableFileMap : public base::NonThreadSafe {
+// A shareable file map with enforcement of sequence checker.
+class ShareableFileMap {
  public:
   typedef std::map<base::FilePath, ShareableFileReference*> FileMap;
   typedef FileMap::iterator iterator;
   typedef FileMap::key_type key_type;
   typedef FileMap::value_type value_type;
 
   ShareableFileMap() {}
 
-  ~ShareableFileMap() {
-    DetachFromThread();
-  }
+  ~ShareableFileMap() = default;
 
   iterator Find(key_type key) {
-    DCHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     return file_map_.find(key);
   }
 
   iterator End() {
-    DCHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     return file_map_.end();
   }
 
   std::pair<iterator, bool> Insert(value_type value) {
-    DCHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     return file_map_.insert(value);
   }
 
   void Erase(key_type key) {
-    DCHECK(CalledOnValidThread());
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
     file_map_.erase(key);
   }
 
+  void AssertCalledOnValidSequence() const {
+    DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  }
+
  private:
   FileMap file_map_;
+
+  SEQUENCE_CHECKER(sequence_checker_);
+
   DISALLOW_COPY_AND_ASSIGN(ShareableFileMap);
 };
 
 base::LazyInstance<ShareableFileMap>::DestructorAtExit g_file_map =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 // static
 scoped_refptr<ShareableFileReference> ShareableFileReference::Get(
@@ skipping 30 matching lines @@
 
   // Wasn't in the map, create a new reference and store the pointer.
   scoped_refptr<ShareableFileReference> reference(
       new ShareableFileReference(std::move(scoped_file)));
   result.first->second = reference.get();
   return reference;
 }
 
 void ShareableFileReference::AddFinalReleaseCallback(
     const FinalReleaseCallback& callback) {
-  DCHECK(g_file_map.Get().CalledOnValidThread());
+  g_file_map.Get().AssertCalledOnValidSequence();

[jianli, 2017/06/01 18:51:05]

This will probably add a couple bytes in release code. Is there a way to avoid
it?

[gab, 2017/06/01 19:02:02]

The AssertCalledOnValidSequence() call would be compiled out because the method
will be empty in release builds. But I think you're right that the
g_file_map.Get() call wouldn't be because the compiler can't infer its
side-effects aren't important.

Wrapped everything in #if DCHECK_IS_ON() to be extra safe.

   scoped_file_.AddScopeOutCallback(callback, NULL);
 }
 
 ShareableFileReference::ShareableFileReference(ScopedFile scoped_file)
     : scoped_file_(std::move(scoped_file)) {
   DCHECK(g_file_map.Get().Find(path())->second == NULL);
 }
 
 ShareableFileReference::~ShareableFileReference() {
   DCHECK(g_file_map.Get().Find(path())->second == this);
   g_file_map.Get().Erase(path());
 }
 
 }  // namespace storage