Fix template angle bracket syntax in platform

Source/platform/CrossThreadCopier.h

 /*
  * Copyright (C) 2009, 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 76 matching lines @@
                         || WTF::IsSameType<RefCountedType*, T>::value),
                         "only one type modification should be allowed");
 
         typedef PassRefPtr<RefCountedType> Type;
         static Type copy(const T& refPtr)
         {
             return refPtr;
         }
     };
 
-    template<typename T> struct CrossThreadCopierBase<false, false, false, PassOwnPtr<T> > {
+    template<typename T> struct CrossThreadCopierBase<false, false, false, PassOwnPtr<T>> {
         typedef PassOwnPtr<T> Type;
         static Type copy(Type ownPtr)
         {
             return ownPtr;
         }
     };
 
     template<typename T> struct CrossThreadCopierBase<false, false, false, WeakMember<T>*> {
         typedef WeakMember<T>* Type;
         static Type copy(Type ptr)
@@ skipping 29 matching lines @@
 
     template<typename T> struct CrossThreadCopierBase<false, false, true, T> {
         typedef typename WTF::RemovePointer<T>::Type TypeWithoutPointer;
         typedef RawPtr<TypeWithoutPointer> Type;
         static Type copy(const T& ptr)
         {
             return ptr;
         }
     };
 
-    template<typename T> struct CrossThreadCopierBase<false, false, true, RawPtr<T> > {
+    template<typename T> struct CrossThreadCopierBase<false, false, true, RawPtr<T>> {
         typedef RawPtr<T> Type;
         static Type copy(const Type& ptr)
         {
             return ptr;
         }
     };
 
-    template<typename T> struct CrossThreadCopierBase<false, false, true, Member<T> > {
+    template<typename T> struct CrossThreadCopierBase<false, false, true, Member<T>> {
         typedef RawPtr<T> Type;
         static Type copy(const Member<T>& ptr)
         {
             return ptr;
         }
     };
 
-    template<typename T> struct CrossThreadCopierBase<false, false, true, WeakMember<T> > {
+    template<typename T> struct CrossThreadCopierBase<false, false, true, WeakMember<T>> {
         typedef RawPtr<T> Type;
         static Type copy(const WeakMember<T>& ptr)
         {
             return ptr;
         }
     };
 
     template<typename T> struct CrossThreadCopier : public CrossThreadCopierBase<WTF::IsConvertibleToInteger<T>::value,
         WTF::IsSubclassOfTemplate<typename WTF::RemoveTemplate<T, RefPtr>::Type, ThreadSafeRefCounted>::value
             || WTF::IsSubclassOfTemplate<typename WTF::RemovePointer<T>::Type, ThreadSafeRefCounted>::value
@@ skipping 13 matching lines @@
     private:
         // This raw pointer is safe since AllowCrossThreadAccessWrapper is
         // always stack-allocated. Ideally this should be Member<T> if T is
         // garbage-collected and T* otherwise, but we don't want to introduce
         // another template magic just for distinguishing Member<T> from T*.
         // From the perspective of GC, T* always works correctly.
         GC_PLUGIN_IGNORE("")
         T* m_value;
     };
 
-    template<typename T> struct CrossThreadCopierBase<false, false, false, AllowCrossThreadAccessWrapper<T> > {
+    template<typename T> struct CrossThreadCopierBase<false, false, false, AllowCrossThreadAccessWrapper<T>> {
         typedef T* Type;
         static Type copy(const AllowCrossThreadAccessWrapper<T>& wrapper) { return wrapper.value(); }
     };
 
     template<typename T> AllowCrossThreadAccessWrapper<T> AllowCrossThreadAccess(T* value)
     {
         return AllowCrossThreadAccessWrapper<T>(value);
     }
 
     // FIXME: Move to a different header file. AllowAccessLater is for cross-thread access
     // that is not cross-thread (tasks posted to a queue guaranteed to run on the same thread).
     template<typename T> struct AllowAccessLaterWrapper {
     public:
         explicit AllowAccessLaterWrapper(T* value) : m_value(value) { }
         T* value() const { return m_value; }
     private:
         // This raw pointer is safe since AllowAccessLaterWrapper is
         // always stack-allocated. Ideally this should be Member<T> if T is
         // garbage-collected and T* otherwise, but we don't want to introduce
         // another template magic just for distinguishing Member<T> from T*.
         // From the perspective of GC, T* always works correctly.
         GC_PLUGIN_IGNORE("")
         T* m_value;
     };
 
-    template<typename T> struct CrossThreadCopierBase<false, false, false, AllowAccessLaterWrapper<T> > {
+    template<typename T> struct CrossThreadCopierBase<false, false, false, AllowAccessLaterWrapper<T>> {
         typedef T* Type;
         static Type copy(const AllowAccessLaterWrapper<T>& wrapper) { return wrapper.value(); }
     };
 
     template<typename T> AllowAccessLaterWrapper<T> AllowAccessLater(T* value)
     {
         return AllowAccessLaterWrapper<T>(value);
     }
 
 
 } // namespace blink
 
 #endif // CrossThreadCopier_h