Mojo: Implement the rest of the WebSocket interface.

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 "mojo/services/html_viewer/blink_basic_type_converters.h"
 #include "mojo/services/public/interfaces/network/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;
 
 namespace mojo {
 
 template<>
-struct TypeConverter<String, WebString> {
-  static String Convert(const WebString& str) {
-    return String(str.utf8());
-  }
-};
-template<>
-struct TypeConverter<WebString, String> {
-  static WebString Convert(const String& str) {
-    return WebString::fromUTF8(str.get());
-  }
-};
-
-template<typename T, typename U>
-struct TypeConverter<Array<T>, WebVector<U> > {
-  static Array<T> Convert(const WebVector<U>& vector) {
-    Array<T> array(vector.size());
-    for (size_t i = 0; i < vector.size(); ++i)
-      array[i] = TypeConverter<T, U>::Convert(vector[i]);
-    return array.Pass();
-  }
-};
-
-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(
         static_cast<MessageType>(WebSocketHandle::MessageTypeContinuation) ==
             WebSocket::MESSAGE_TYPE_CONTINUATION,
         enum_values_must_match_for_message_type);
@@ skipping 27 matching lines @@
                                blink::WebSocketHandleClient* client)
       : handle_(handle), client_(client) {}
   virtual ~WebSocketClientImpl() {}
 
  private:
   // WebSocketClient methods:
   virtual void DidConnect(
       bool fail,
       const String& selected_subprotocol,
       const String& extensions) OVERRIDE {
-    client_->didConnect(handle_,
-                        fail,
-                        selected_subprotocol.To<WebString>(),
-                        extensions.To<WebString>());
+    blink::WebSocketHandleClient* client = client_;
+    WebSocketHandleImpl* handle = handle_;
+    if (fail)
+      handle->Disconnect();  // deletes |this|
+    client->didConnect(handle,
+                       fail,
+                       selected_subprotocol.To<WebString>(),
+                       extensions.To<WebString>());
+    // |handle_| can be deleted here.
   }
+
   virtual void DidReceiveData(bool fin,
                               WebSocket::MessageType type,
                               ScopedDataPipeConsumerHandle data_pipe) OVERRIDE {
     uint32_t num_bytes;
     ReadDataRaw(data_pipe.get(), NULL, &num_bytes, MOJO_READ_DATA_FLAG_QUERY);
     std::vector<char> data(num_bytes);
     ReadDataRaw(
         data_pipe.get(), &data[0], &num_bytes, MOJO_READ_DATA_FLAG_NONE);
     const char* data_ptr = data.empty() ? NULL : &data[0];
     client_->didReceiveData(handle_,
                             fin,
                             ConvertTo<WebSocketHandle::MessageType>(type),
                             data_ptr,
                             data.size());
+    // |handle_| can be deleted here.
   }
 
   virtual void DidReceiveFlowControl(int64_t quota) OVERRIDE {
     client_->didReceiveFlowControl(handle_, quota);
     // |handle_| can be deleted here.
   }
 
+  virtual void DidFail(const String& message) OVERRIDE {
+    blink::WebSocketHandleClient* client = client_;
+    WebSocketHandleImpl* handle = handle_;
+    handle->Disconnect();  // deletes |this|
+    client->didFail(handle, message.To<WebString>());
+    // |handle_| can be deleted here.
+  }
+
+  virtual void DidClose(bool was_clean,
+                        uint16_t code,
+                        const String& reason) OVERRIDE {
+    blink::WebSocketHandleClient* client = client_;
+    WebSocketHandleImpl* handle = handle_;
+    handle->Disconnect();  // deletes |this|
+    client->didClose(handle, was_clean, code, reason.To<WebString>());
+    // |handle_| can be deleted here.

[darin (slow to review), 2014/09/05 18:54:15]

hmm, this comment is a bit fishy since |this| is already deleted. maybe the
comment should say "handle" instead of "handle_"? ditto for the others?

[Matt Perry, 2014/09/05 19:49:07]

Done.

+  }
+
   WebSocketHandleImpl* handle_;
   blink::WebSocketHandleClient* client_;
 
   DISALLOW_COPY_AND_ASSIGN(WebSocketClientImpl);
 };
 
 WebSocketHandleImpl::WebSocketHandleImpl(NetworkService* network_service)
     : did_close_(false) {
   network_service->CreateWebSocket(Get(&web_socket_));
 }
@@ skipping 47 matching lines @@
 }
 
 void WebSocketHandleImpl::flowControl(int64_t quota) {
   if (!client_)
     return;
 
   web_socket_->FlowControl(quota);
 }
 
 void WebSocketHandleImpl::close(unsigned short code, const WebString& reason) {
-  did_close_ = true;
   web_socket_->Close(code, reason.utf8());
 }
 
+void WebSocketHandleImpl::Disconnect() {
+  did_close_ = true;
+  client_.reset();
+}
+
 }  // namespace mojo