Move implementation from header to source.

base/weak_ptr.h

 // Copyright (c) 2009 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 pointers help in cases where you have many objects referring back to a
 // shared object and you wish for the lifetime of the shared object to not be
 // bound to the lifetime of the referrers.  In other words, this is useful when
 // reference counting is not a good fit.
 //
 // A common alternative to weak pointers is to have the shared object hold a
@@ skipping 47 matching lines @@
 namespace base {
 
 namespace internal {
 // These classes are part of the WeakPtr implementation.
 // DO NOT USE THESE CLASSES DIRECTLY YOURSELF.
 
 class WeakReference {
  public:
   class Flag : public RefCounted<Flag>, public NonThreadSafe {
    public:
-    Flag(Flag** handle) : handle_(handle) {
-    }
+    Flag(Flag** handle);
+    ~Flag();
 
-    ~Flag() {
-      if (handle_)
-        *handle_ = NULL;
-    }
-
-    void AddRef() {
-      DCHECK(CalledOnValidThread());
-      RefCounted<Flag>::AddRef();
-    }
-
-    void Release() {
-      DCHECK(CalledOnValidThread());
-      RefCounted<Flag>::Release();
-    }
-
+    void AddRef();
+    void Release();
     void Invalidate() { handle_ = NULL; }
     bool is_valid() const { return handle_ != NULL; }
 
    private:
     Flag** handle_;
   };
 
-  WeakReference() {}
-  WeakReference(Flag* flag) : flag_(flag) {}
+  WeakReference();
+  WeakReference(Flag* flag);
 
-  bool is_valid() const { return flag_ && flag_->is_valid(); }
+  bool is_valid() const;
 
  private:
   scoped_refptr<Flag> flag_;
 };
 
 class WeakReferenceOwner {
  public:
-  WeakReferenceOwner() : flag_(NULL) {
-  }
+  WeakReferenceOwner();
+  ~WeakReferenceOwner();
 
-  ~WeakReferenceOwner() {
-    Invalidate();
-  }
-
-  WeakReference GetRef() const {
-    if (!flag_)
-      flag_ = new WeakReference::Flag(&flag_);
-    return WeakReference(flag_);
-  }
+  WeakReference GetRef() const;
 
   bool HasRefs() const {
     return flag_ != NULL;
   }
 
-  void Invalidate() {
-    if (flag_) {
-      flag_->Invalidate();
-      flag_ = NULL;
-    }
-  }
+  void Invalidate();
 
  private:
   mutable WeakReference::Flag* flag_;
 };
 
 // This class simplifies the implementation of WeakPtr's type conversion
 // constructor by avoiding the need for a public accessor for ref_.  A
 // WeakPtr<T> cannot access the private members of WeakPtr<U>, so this
 // base class gives us a way to access ref_ in a protected fashion.
 class WeakPtrBase {
  public:
-  WeakPtrBase() {
-  }
+  WeakPtrBase();
 
  protected:
-  WeakPtrBase(const WeakReference& ref) : ref_(ref) {
-  }
+  WeakPtrBase(const WeakReference& ref);
 
   WeakReference ref_;
 };
 
 }  // namespace internal
 
 template <typename T> class SupportsWeakPtr;
 template <typename T> class WeakPtrFactory;
 
 // The WeakPtr class holds a weak reference to |T*|.
@@ skipping 95 matching lines @@
 
  private:
   internal::WeakReferenceOwner weak_reference_owner_;
   T* ptr_;
   DISALLOW_IMPLICIT_CONSTRUCTORS(WeakPtrFactory);
 };
 
 }  // namespace base
 
 #endif  // BASE_WEAK_PTR_H_