Deprecate NonThreadSafe in components/sync in favor of SequenceChecker.

components/sync/base/weak_handle.h

 // Copyright 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 COMPONENTS_SYNC_BASE_WEAK_HANDLE_H_
 #define COMPONENTS_SYNC_BASE_WEAK_HANDLE_H_
 
 #include <cstddef>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 
-// Weak handles provides a way to refer to weak pointers from another
+// SEQUENCE_CHECKER(sequence_checker_);

[stanisc, 2017/05/30 17:00:08]

It looks like the script didn't handle this correctly. This comment makes no
sense. Also the next line has an extra //

[gab, 2017/05/31 17:42:23]

Whoops..! Spent a lot of time to make the script handle that... and somehow
messed it up in last version of script which tries to insert above comments to
insertion point (which of course doesn't work for code inside a comment!).

Thankfully this appears to be the only comment with NonThreadSafe in it :) --
guess I should have checked that first before trying hard to handle a use case
for which there was one instance and then failing to do so..!

Fixed.

+//// Weak handles provides a way to refer to weak pointers from another
 // thread.  This is useful because it is not safe to reference a weak
 // pointer from a thread other than the thread on which it was
 // created.
 //
 // Weak handles can be passed across threads, so for example, you can
 // use them to do the "real" work on one thread and get notified on
 // another thread:
 //
 // class FooIOWorker {
 //  public:
 //   FooIOWorker(const WeakHandle<Foo>& foo) : foo_(foo) {}
 //
 //   void OnIOStart() {
 //     foo_.Call(FROM_HERE, &Foo::OnIOStart);
 //   }
 //
 //   void OnIOEvent(IOEvent e) {
 //     foo_.Call(FROM_HERE, &Foo::OnIOEvent, e);
 //   }
 //
 //   void OnIOError(IOError err) {
 //     foo_.Call(FROM_HERE, &Foo::OnIOError, err);
 //   }
 //
 //  private:
 //   const WeakHandle<Foo> foo_;
 // };
 //
-// class Foo : public SupportsWeakPtr<Foo>, public NonThreadSafe {
+// class Foo : public SupportsWeakPtr<Foo> {
 //  public:
 //   Foo() {
 //     SpawnFooIOWorkerOnIOThread(base::MakeWeakHandle(AsWeakPtr()));
 //   }
 //
 //   /* Will always be called on the correct thread, and only if this
 //      object hasn't been destroyed. */
 //   void OnIOStart() { DCHECK(CalledOnValidThread(); ... }
 //   void OnIOEvent(IOEvent e) { DCHECK(CalledOnValidThread(); ... }
 //   void OnIOError(IOError err) { DCHECK(CalledOnValidThread(); ... }
@@ skipping 133 matching lines @@
 
 // Makes a WeakHandle from a WeakPtr.
 template <typename T>
 WeakHandle<T> MakeWeakHandle(const base::WeakPtr<T>& ptr) {
   return WeakHandle<T>(ptr);
 }
 
 }  // namespace syncer
 
 #endif  // COMPONENTS_SYNC_BASE_WEAK_HANDLE_H_