Update sync::WeakHandle to use WeakPtr<T>::get()

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 193 matching lines @@
 
   // GCC 4.2.1 on OS X gets confused if all the DoCall functions are
   // named the same, so we distinguish them.
 
   template <typename U>
   void DoCall0(void (U::*fn)(void)) const {
     CHECK(IsOnOwnerThread());
     if (!Get()) {
       return;
     }
-    (Get()->*fn)();
+    (Get().get()->*fn)();
   }
 
   template <typename U, typename A1>
   void DoCall1(void (U::*fn)(A1),
                typename ParamTraits<A1>::ForwardType a1) const {
     CHECK(IsOnOwnerThread());
     if (!Get()) {
       return;
     }
-    (Get()->*fn)(a1);
+    (Get().get()->*fn)(a1);
   }
 
   template <typename U, typename A1, typename A2>
   void DoCall2(void (U::*fn)(A1, A2),
                typename ParamTraits<A1>::ForwardType a1,
                typename ParamTraits<A2>::ForwardType a2) const {
     CHECK(IsOnOwnerThread());
     if (!Get()) {
       return;
     }
-    (Get()->*fn)(a1, a2);
+    (Get().get()->*fn)(a1, a2);
   }
 
   template <typename U, typename A1, typename A2, typename A3>
   void DoCall3(void (U::*fn)(A1, A2, A3),
                typename ParamTraits<A1>::ForwardType a1,
                typename ParamTraits<A2>::ForwardType a2,
                typename ParamTraits<A3>::ForwardType a3) const {
     CHECK(IsOnOwnerThread());
     if (!Get()) {
       return;
     }
-    (Get()->*fn)(a1, a2, a3);
+    (Get().get()->*fn)(a1, a2, a3);
   }
 
   template <typename U, typename A1, typename A2, typename A3, typename A4>
   void DoCall4(void (U::*fn)(A1, A2, A3, A4),
                typename ParamTraits<A1>::ForwardType a1,
                typename ParamTraits<A2>::ForwardType a2,
                typename ParamTraits<A3>::ForwardType a3,
                typename ParamTraits<A4>::ForwardType a4) const {
     CHECK(IsOnOwnerThread());
     if (!Get()) {
       return;
     }
-    (Get()->*fn)(a1, a2, a3, a4);
+    (Get().get()->*fn)(a1, a2, a3, a4);
   }
 
   // Must be dereferenced only on the owner thread.  May be destroyed
   // from any thread.
   base::WeakPtr<T> ptr_;
 
   DISALLOW_COPY_AND_ASSIGN(WeakHandleCore);
 };
 
 }  // namespace internal
@@ skipping 99 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_