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

third_party/WebKit/Source/wtf/UniquePtrTransitionGuide.md

 # std::unique_ptr Transition Guide
 
 Now `std::unique_ptr<T>` is available anywhere in Blink. This document goes through various use cases of `OwnPtr<T>`
 and how they get converted to `std::unique_ptr<T>` so you can smoothly switch your mind.
 
 If you have any uncertainties on using `std::unique_ptr<T>`, ask yutak@chromium.org (or other C++ gurus around you)
 for help.
 
 ## Creation and Use
 
@@ skipping 12 matching lines @@
     T* leakedPointer = owned.leakPtr();
 }
 ```
 
 #### std::unique_ptr
 
 ```c++
 void f()
 {
     std::unique_ptr<T> owned(new T(argument));
-    // Or: auto owned = wrapUnique(new T(argument)); †1
+    // Or: auto owned = WTF::wrapUnique(new T(argument)); †1
     owned->useThis();
     T& reference = *owned;
     T* pointer = owned.get();
     owned.reset();      // Or: owned = nullptr
-    owned.reset(new T); // Or: owned = wrapUnique(new T)
+    owned.reset(new T); // Or: owned = WTF::wrapUnique(new T)
     T* leakedPointer = owned.release();
 }
 ```
 |||---|||
 
-†1 `wrapUnique()` is particularly useful when you pass a `unique_ptr` to somebody else:
+†1 `WTF::wrapUnique()` is particularly useful when you pass a `unique_ptr` to somebody else:
 
 ```c++
 std::unique_ptr<T> g()
 {
-    h(wrapUnique(new T(argument))); // Pass to a function.
-    return wrapUnique(new T(argument)); // Return from a function.
+    h(WTF::wrapUnique(new T(argument))); // Pass to a function.
+    return WTF::wrapUnique(new T(argument)); // Return from a function.
 }
 
 ```
 
-You need to `#include "wtf/PtrUtil.h"` for `wrapUnique()`.
+You need to `#include "wtf/PtrUtil.h"` for `WTF::wrapUnique()`.
 
 ## Passing and Receiving
 
 |||---|||
 #### OwnPtr
 
 ```c++
 void receive(PassOwnPtr<T> object)
 {
     OwnPtr<T> localObject = object;
@@ skipping 81 matching lines @@
 an lvalue. This is possible because `return` makes all the local variables go away by going back to the caller.
 
 *** aside
 *Note:* Well, yes, I know, the definitions of lvalues and rvalues here are not very precise. However, the above
 understandings are sufficient in practice. If you want to know further, see
 [the wiki about value categories at cppreference.com](http://en.cppreference.com/w/cpp/language/value_category).
 
 See also [Dana's guide for rvalue references](https://sites.google.com/a/chromium.org/dev/rvalue-references)
 if you want to learn about move semantics.
 ***