Move HTMLViewer out of mojo namespace

mojo/services/html_viewer/websockethandle_impl.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/services/html_viewer/websockethandle_impl.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/scoped_vector.h"
 #include "mojo/services/html_viewer/blink_basic_type_converters.h"
 #include "mojo/services/network/public/cpp/web_socket_read_queue.h"
 #include "mojo/services/network/public/cpp/web_socket_write_queue.h"
 #include "mojo/services/network/public/interfaces/network_service.mojom.h"
 #include "third_party/WebKit/public/platform/WebSerializedOrigin.h"
 #include "third_party/WebKit/public/platform/WebSocketHandleClient.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 
 using blink::WebSerializedOrigin;
 using blink::WebSocketHandle;
 using blink::WebSocketHandleClient;
 using blink::WebString;
 using blink::WebURL;
 using blink::WebVector;
 
+using mojo::ConvertTo;
+using mojo::String;
+using mojo::WebSocket;
+using mojo::WebSocketReadQueue;
+
 namespace mojo {
 
 template<>
 struct TypeConverter<WebSocket::MessageType, WebSocketHandle::MessageType> {
   static WebSocket::MessageType Convert(WebSocketHandle::MessageType type) {
     DCHECK(type == WebSocketHandle::MessageTypeContinuation ||
            type == WebSocketHandle::MessageTypeText ||
            type == WebSocketHandle::MessageTypeBinary);
     typedef WebSocket::MessageType MessageType;
     COMPILE_ASSERT(
@@ skipping 15 matching lines @@
 template<>
 struct TypeConverter<WebSocketHandle::MessageType, WebSocket::MessageType> {
   static WebSocketHandle::MessageType Convert(WebSocket::MessageType type) {
     DCHECK(type == WebSocket::MESSAGE_TYPE_CONTINUATION ||
            type == WebSocket::MESSAGE_TYPE_TEXT ||
            type == WebSocket::MESSAGE_TYPE_BINARY);
     return static_cast<WebSocketHandle::MessageType>(type);
   }
 };
 
+}  // namespace mojo
+
+namespace html_viewer {
+
 // This class forms a bridge from the mojo WebSocketClient interface and the
 // Blink WebSocketHandleClient interface.
-class WebSocketClientImpl : public InterfaceImpl<WebSocketClient> {
+class WebSocketClientImpl : public mojo::InterfaceImpl<mojo::WebSocketClient> {
  public:
   explicit WebSocketClientImpl(WebSocketHandleImpl* handle,
                                blink::WebSocketHandleClient* client)
       : handle_(handle), client_(client) {}
   ~WebSocketClientImpl() override {}
 
  private:
   // WebSocketClient methods:
   void DidConnect(bool fail,
                   const String& selected_subprotocol,
                   const String& extensions,
-                  ScopedDataPipeConsumerHandle receive_stream) override {
+                  mojo::ScopedDataPipeConsumerHandle receive_stream) override {
     blink::WebSocketHandleClient* client = client_;
     WebSocketHandleImpl* handle = handle_;
     receive_stream_ = receive_stream.Pass();
     read_queue_.reset(new WebSocketReadQueue(receive_stream_.get()));
     if (fail)
       handle->Disconnect();  // deletes |this|
     client->didConnect(handle,
                        fail,
                        selected_subprotocol.To<WebString>(),
                        extensions.To<WebString>());
@@ skipping 38 matching lines @@
                             fin,
                             ConvertTo<WebSocketHandle::MessageType>(type),
                             data,
                             num_bytes);
     // |handle_| can be deleted here.
   }
 
   // |handle_| owns this object, so it is guaranteed to outlive us.
   WebSocketHandleImpl* handle_;
   blink::WebSocketHandleClient* client_;
-  ScopedDataPipeConsumerHandle receive_stream_;
+  mojo::ScopedDataPipeConsumerHandle receive_stream_;
   scoped_ptr<WebSocketReadQueue> read_queue_;
 
   DISALLOW_COPY_AND_ASSIGN(WebSocketClientImpl);
 };
 
-WebSocketHandleImpl::WebSocketHandleImpl(NetworkService* network_service)
+WebSocketHandleImpl::WebSocketHandleImpl(mojo::NetworkService* network_service)
     : did_close_(false) {
   network_service->CreateWebSocket(GetProxy(&web_socket_));
 }
 
 WebSocketHandleImpl::~WebSocketHandleImpl() {
   if (!did_close_) {
     // The connection is abruptly disconnected by the renderer without
     // closing handshake.
     web_socket_->Close(WebSocket::kAbnormalCloseCode, String());
   }
 }
 
 void WebSocketHandleImpl::connect(const WebURL& url,
                                   const WebVector<WebString>& protocols,
                                   const WebSerializedOrigin& origin,
                                   WebSocketHandleClient* client) {
   client_.reset(new WebSocketClientImpl(this, client));
-  WebSocketClientPtr client_ptr;
+  mojo::WebSocketClientPtr client_ptr;
   // TODO(mpcomplete): Is this the right ownership model? Or should mojo own
   // |client_|?
   WeakBindToProxy(client_.get(), &client_ptr);
 
-  DataPipe data_pipe;
+  mojo::DataPipe data_pipe;
   send_stream_ = data_pipe.producer_handle.Pass();
-  write_queue_.reset(new WebSocketWriteQueue(send_stream_.get()));
+  write_queue_.reset(new mojo::WebSocketWriteQueue(send_stream_.get()));
   web_socket_->Connect(url.string().utf8(),
-                       Array<String>::From(protocols),
-                       origin.string().utf8(),
-                       data_pipe.consumer_handle.Pass(),
+                       mojo::Array<String>::From(protocols),
+                       origin.string().utf8(), data_pipe.consumer_handle.Pass(),
                        client_ptr.Pass());
 }
 
 void WebSocketHandleImpl::send(bool fin,
                                WebSocketHandle::MessageType type,
                                const char* data,
                                size_t size) {
   if (!client_)
     return;
 
@@ skipping 22 matching lines @@
     uint32_t num_bytes,
     const char* data) {
   web_socket_->Send(fin, ConvertTo<WebSocket::MessageType>(type), num_bytes);
 }
 
 void WebSocketHandleImpl::Disconnect() {
   did_close_ = true;
   client_.reset();
 }
 
-}  // namespace mojo
+}  // namespace html_viewer