Fix template angle bracket syntax in inspector

Source/core/inspector/PromiseTracker.cpp

 // Copyright 2014 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.
 
 #include "config.h"
 #include "core/inspector/PromiseTracker.h"
 
 #include "bindings/core/v8/ScopedPersistent.h"
 #include "bindings/core/v8/ScriptCallStackFactory.h"
 #include "bindings/core/v8/ScriptState.h"
@@ skipping 126 matching lines @@
     static PassOwnPtrWillBeRawPtr<PromiseDataWrapper> create(PromiseTracker::PromiseData* data, PromiseTracker* tracker)
     {
 #if ENABLE(OILPAN)
         return new PromiseDataWrapper(data, tracker);
 #else
         return adoptPtr(new PromiseDataWrapper(data->createWeakPtr(), tracker));
 #endif
     }
 
 #if ENABLE(OILPAN)
-    static void didRemovePromise(const v8::WeakCallbackData<v8::Object, Persistent<PromiseDataWrapper> >& data)
+    static void didRemovePromise(const v8::WeakCallbackData<v8::Object, Persistent<PromiseDataWrapper>>& data)
 #else
     static void didRemovePromise(const v8::WeakCallbackData<v8::Object, PromiseDataWrapper>& data)
 #endif
     {
 #if ENABLE(OILPAN)
-        OwnPtr<Persistent<PromiseDataWrapper> > persistentWrapper = adoptPtr(data.GetParameter());
+        OwnPtr<Persistent<PromiseDataWrapper>> persistentWrapper = adoptPtr(data.GetParameter());
         RawPtr<PromiseDataWrapper> wrapper = *persistentWrapper;
 #else
         OwnPtr<PromiseDataWrapper> wrapper = adoptPtr(data.GetParameter());
 #endif
         WeakPtrWillBeRawPtr<PromiseTracker::PromiseData> promiseData = wrapper->m_data;
         if (!promiseData || !wrapper->m_tracker)
             return;
 
         PromiseTracker::Listener* listener = wrapper->m_tracker->listener();
         if (listener)
@@ skipping 100 matching lines @@
         vector = &m_promiseDataMap.add(promiseHash, PromiseDataVector()).storedValue->value;
     }
 
     // FIXME: Consider using the ScriptState's DOMWrapperWorld instead
     // to handle the lifetime of PromiseDataWrapper, avoiding all this
     // manual labor to achieve the same, with and without Oilpan.
     int promiseId = circularSequentialId();
     RefPtrWillBeRawPtr<PromiseData> data = PromiseData::create(scriptState, promiseHash, promiseId, promise);
     OwnPtrWillBeRawPtr<PromiseDataWrapper> dataWrapper = PromiseDataWrapper::create(data.get(), this);
 #if ENABLE(OILPAN)
-    OwnPtr<Persistent<PromiseDataWrapper> > wrapper = adoptPtr(new Persistent<PromiseDataWrapper>(dataWrapper));
+    OwnPtr<Persistent<PromiseDataWrapper>> wrapper = adoptPtr(new Persistent<PromiseDataWrapper>(dataWrapper));
 #else
     OwnPtr<PromiseDataWrapper> wrapper = dataWrapper.release();
 #endif
     data->m_promise.setWeak(wrapper.leakPtr(), &PromiseDataWrapper::didRemovePromise);
     vector->append(data);
 
     m_promiseIdToDataMap.set(promiseId, data);
 
     return data.release();
 }
@@ skipping 34 matching lines @@
                 if (stack && stack->size())
                     data->m_settlementStack = stack;
             }
         }
     }
 
     if (m_listener)
         m_listener->didUpdatePromise(eventType, data->toPromiseDetails());
 }
 
-PassRefPtr<Array<PromiseDetails> > PromiseTracker::promises()
+PassRefPtr<Array<PromiseDetails>> PromiseTracker::promises()
 {
     ASSERT(isEnabled());
-    RefPtr<Array<PromiseDetails> > result = Array<PromiseDetails>::create();
+    RefPtr<Array<PromiseDetails>> result = Array<PromiseDetails>::create();
     for (auto& data : m_promiseDataMap) {
         PromiseDataVector* vector = &data.value;
         for (size_t index = 0; index < vector->size(); ++index)
             result->addItem(vector->at(index)->toPromiseDetails());
     }
     return result.release();
 }
 
 ScriptValue PromiseTracker::promiseById(int promiseId) const
 {
     ASSERT(isEnabled());
 
     PromiseIdToDataMap::const_iterator it = m_promiseIdToDataMap.find(promiseId);
     if (it == m_promiseIdToDataMap.end())
         return ScriptValue();
     RefPtrWillBeRawPtr<PromiseData> data = it->value;
     ASSERT(data && data->m_promiseId == promiseId);
     ScriptState* scriptState = data->m_scriptState.get();
     v8::HandleScope scope(scriptState->isolate());
     return ScriptValue(scriptState, data->m_promise.newLocal(scriptState->isolate()));
 }
 
 } // namespace blink