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

third_party/WebKit/Source/platform/graphics/gpu/SharedGpuContext.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 "platform/graphics/gpu/SharedGpuContext.h"
 
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "platform/CrossThreadFunctional.h"
 #include "platform/WaitableEvent.h"
 #include "platform/WebTaskRunner.h"
@@ skipping 12 matching lines @@
 SharedGpuContext::SharedGpuContext() : m_contextId(kNoSharedContext) {
   createContextProviderIfNeeded();
 }
 
 void SharedGpuContext::createContextProviderOnMainThread(
     WaitableEvent* waitableEvent) {
   DCHECK(isMainThread());
   Platform::ContextAttributes contextAttributes;
   contextAttributes.webGLVersion = 1;  // GLES2
   Platform::GraphicsInfo graphicsInfo;
-  m_contextProvider =
-      wrapUnique(Platform::current()->createOffscreenGraphicsContext3DProvider(
+  m_contextProvider = WTF::wrapUnique(
+      Platform::current()->createOffscreenGraphicsContext3DProvider(
           contextAttributes, WebURL(), nullptr, &graphicsInfo));
   if (waitableEvent)
     waitableEvent->signal();
 }
 
 void SharedGpuContext::createContextProviderIfNeeded() {
   if (m_contextProvider &&
       m_contextProvider->contextGL()->GetGraphicsResetStatusKHR() ==
           GL_NO_ERROR)
     return;
 
   std::unique_ptr<WebGraphicsContext3DProvider> oldContextProvider =
       std::move(m_contextProvider);
   if (m_contextProviderFactory) {
     // This path should only be used in unit tests
     m_contextProvider = m_contextProviderFactory();
   } else if (isMainThread()) {
     m_contextProvider =
-        wrapUnique(blink::Platform::current()
-                       ->createSharedOffscreenGraphicsContext3DProvider());
+        WTF::wrapUnique(blink::Platform::current()
+                            ->createSharedOffscreenGraphicsContext3DProvider());
   } else {
     // This synchronous round-trip to the main thread is the reason why
     // SharedGpuContext encasulates the context provider: so we only have to do
     // this once per thread.
     WaitableEvent waitableEvent;
     WebTaskRunner* taskRunner =
         Platform::current()->mainThread()->getWebTaskRunner();
     taskRunner->postTask(
         BLINK_FROM_HERE,
         crossThreadBind(&SharedGpuContext::createContextProviderOnMainThread,
@@ skipping 56 matching lines @@
 
 bool SharedGpuContext::isValidWithoutRestoring() {
   SharedGpuContext* thisPtr = getInstanceForCurrentThread();
   if (!thisPtr->m_contextProvider)
     return false;
   return thisPtr->m_contextProvider->contextGL()->GetGraphicsResetStatusKHR() ==
          GL_NO_ERROR;
 }
 
 }  // blink