[sync] Componentize sync: Part 6: Add more SYNC_EXPORTs to files in src/sync/

sync/internal_api/public/util/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.
 
 // 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
@@ skipping 91 matching lines @@
 class WeakHandleCoreBase {
  public:
   // Assumes the current thread is the owner thread.
   WeakHandleCoreBase();
 
   // May be called on any thread.
   bool IsOnOwnerThread() const;
 
  protected:
   // May be destroyed on any thread.
-  ~WeakHandleCoreBase();
+  virtual ~WeakHandleCoreBase();
 
   // May be called on any thread.
   void PostToOwnerThread(const tracked_objects::Location& from_here,
                          const base::Closure& fn) const;
 
  private:
   // May be used on any thread.
   const scoped_refptr<base::MessageLoopProxy> owner_loop_proxy_;
 
   DISALLOW_COPY_AND_ASSIGN(WeakHandleCoreBase);
 };
 
 // WeakHandleCore<T> contains all the logic for WeakHandle<T>.
 template <typename T>
 class WeakHandleCore
     : public NON_EXPORTED_BASE(WeakHandleCoreBase),

[Raghu Simha, 2012/12/26 08:02:38]

Note: I had added this NON_EXPORTED_BASE annotation in a previous CL thinking it
made sense. It doesn't, since the classes that inherit from WeakHandleCoreBase
are all template classes that are entirely defined in the header file, and
therefore, do not need to be exported.

       public base::RefCountedThreadSafe<WeakHandleCore<T> > {
  public:
   // Must be called on |ptr|'s owner thread, which is assumed to be
   // the current thread.
   explicit WeakHandleCore(const base::WeakPtr<T>& ptr) : ptr_(ptr) {}
 
   // Must be called on |ptr_|'s owner thread.
   base::WeakPtr<T> Get() const {
     CHECK(IsOnOwnerThread());
     return ptr_;
@@ skipping 230 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  // SYNC_UTIL_WEAK_HANDLE_H_