s/ passed(...) / WTF::passed(...) / to avoid future ambiguity w/ base::Passed.

third_party/WebKit/Source/core/inspector/ThreadDebugger.cpp

 // Copyright 2016 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 "core/inspector/ThreadDebugger.h"
 
 #include "bindings/core/v8/SourceLocation.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8DOMException.h"
 #include "bindings/core/v8/V8DOMTokenList.h"
@@ skipping 119 matching lines @@
 }
 
 void ThreadDebugger::promiseRejectionRevoked(v8::Local<v8::Context> context,
                                              unsigned promiseRejectionId) {
   const String message = "Handler added to rejected promise";
   v8Inspector()->exceptionRevoked(context, promiseRejectionId,
                                   toV8InspectorStringView(message));
 }
 
 void ThreadDebugger::beginUserGesture() {
-  m_userGestureIndicator = wrapUnique(
+  m_userGestureIndicator = WTF::wrapUnique(
       new UserGestureIndicator(DocumentUserGestureToken::create(nullptr)));
 }
 
 void ThreadDebugger::endUserGesture() {
   m_userGestureIndicator.reset();
 }
 
 std::unique_ptr<v8_inspector::StringBuffer> ThreadDebugger::valueSubtype(
     v8::Local<v8::Value> value) {
   static const char kNode[] = "node";
@@ skipping 301 matching lines @@
                                     toCoreString(title)));
 }
 
 void ThreadDebugger::startRepeatingTimer(
     double interval,
     V8InspectorClient::TimerCallback callback,
     void* data) {
   m_timerData.append(data);
   m_timerCallbacks.append(callback);
 
-  std::unique_ptr<Timer<ThreadDebugger>> timer =
-      wrapUnique(new Timer<ThreadDebugger>(this, &ThreadDebugger::onTimer));
+  std::unique_ptr<Timer<ThreadDebugger>> timer = WTF::wrapUnique(
+      new Timer<ThreadDebugger>(this, &ThreadDebugger::onTimer));
   Timer<ThreadDebugger>* timerPtr = timer.get();
   m_timers.append(std::move(timer));
   timerPtr->startRepeating(interval, BLINK_FROM_HERE);
 }
 
 void ThreadDebugger::cancelTimer(void* data) {
   for (size_t index = 0; index < m_timerData.size(); ++index) {
     if (m_timerData[index] == data) {
       m_timers[index]->stop();
       m_timerCallbacks.remove(index);
       m_timers.remove(index);
       m_timerData.remove(index);
       return;
     }
   }
 }
 
 void ThreadDebugger::onTimer(TimerBase* timer) {
   for (size_t index = 0; index < m_timers.size(); ++index) {
     if (m_timers[index].get() == timer) {
       m_timerCallbacks[index](m_timerData[index]);
       return;
     }
   }
 }
 
 }  // namespace blink