[Mojo] Fix the namespace for HandleWrapper

mojo/bindings/js/core.cc

 // 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 "mojo/bindings/js/core.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "gin/arguments.h"
 #include "gin/array_buffer.h"
 #include "gin/converter.h"
 #include "gin/dictionary.h"
 #include "gin/function_template.h"
 #include "gin/handle.h"
 #include "gin/object_template_builder.h"
 #include "gin/per_isolate_data.h"
 #include "gin/public/wrapper_info.h"
 #include "gin/wrappable.h"
 #include "mojo/bindings/js/drain_data.h"
 #include "mojo/bindings/js/handle.h"
 
 namespace mojo {
 namespace js {
 
 namespace {
 
-MojoResult CloseHandle(gin::Handle<gin::HandleWrapper> handle) {
+MojoResult CloseHandle(gin::Handle<HandleWrapper> handle) {
   if (!handle->get().is_valid())
     return MOJO_RESULT_INVALID_ARGUMENT;
   handle->Close();
   return MOJO_RESULT_OK;
 }
 
 MojoResult WaitHandle(mojo::Handle handle,
                       MojoHandleSignals signals,
                       MojoDeadline deadline) {
   return MojoWait(handle.value(), signals, deadline);
@@ skipping 39 matching lines @@
 
   dictionary.Set("result", result);
   dictionary.Set("handle0", mojo::Handle(handle0));
   dictionary.Set("handle1", mojo::Handle(handle1));
   return dictionary;
 }
 
 MojoResult WriteMessage(
     mojo::Handle handle,
     const gin::ArrayBufferView& buffer,
-    const std::vector<gin::Handle<gin::HandleWrapper> >& handles,
+    const std::vector<gin::Handle<HandleWrapper> >& handles,
     MojoWriteMessageFlags flags) {
   std::vector<MojoHandle> raw_handles(handles.size());
   for (size_t i = 0; i < handles.size(); ++i)
     raw_handles[i] = handles[i]->get().value();
   MojoResult rv = MojoWriteMessage(handle.value(),
                           buffer.bytes(),
                           static_cast<uint32_t>(buffer.num_bytes()),
                           raw_handles.empty() ? NULL : &raw_handles[0],
                           static_cast<uint32_t>(raw_handles.size()),
                           flags);
@@ skipping 126 matching lines @@
 
 // Asynchronously read all of the data available for the specified data pipe
 // consumer handle until the remote handle is closed or an error occurs. A
 // Promise is returned whose settled value is an object like this:
 // {result: core.RESULT_OK, buffer: dataArrayBuffer}. If the read failed,
 // then the Promise is rejected, the result will be the actual error code,
 // and the buffer will contain whatever was read before the error occurred.
 // The drainData data pipe handle argument is closed automatically.
 
 v8::Handle<v8::Value> DoDrainData(gin::Arguments* args,
-                                  gin::Handle<gin::HandleWrapper> handle) {
+                                  gin::Handle<HandleWrapper> handle) {
   return (new DrainData(args->isolate(), handle->release()))->GetPromise();
 }
 
 gin::WrapperInfo g_wrapper_info = { gin::kEmbedderNativeGin };
 
 }  // namespace
 
 const char Core::kModuleName[] = "mojo/public/js/bindings/core";
 
 v8::Local<v8::Value> Core::GetModule(v8::Isolate* isolate) {
@@ skipping 67 matching lines @@
         .Build();
 
     data->SetObjectTemplate(&g_wrapper_info, templ);
   }
 
   return templ->NewInstance();
 }
 
 }  // namespace js
 }  // namespace mojo