WebSocket Pepper API: GetBufferedAmount() implementation

webkit/plugins/ppapi/ppb_websocket_impl.cc

 // Copyright (c) 2011 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 "webkit/plugins/ppapi/ppb_websocket_impl.h"
 
 #include <string>
 
+#include "base/basictypes.h"
 #include "base/logging.h"
 #include "googleurl/src/gurl.h"
 #include "net/base/net_util.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_var.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/shared_impl/var_tracker.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebData.h"
@@ skipping 11 matching lines @@
 using ppapi::StringVar;
 using ppapi::thunk::PPB_WebSocket_API;
 using ppapi::VarTracker;
 using WebKit::WebData;
 using WebKit::WebDocument;
 using WebKit::WebString;
 using WebKit::WebSocket;
 using WebKit::WebSocketClient;
 using WebKit::WebURL;
 
-static const uint32_t kMaxReasonSizeInBytes = 123;
+namespace {
+
+const uint32_t kMaxReasonSizeInBytes = 123;
+const size_t kHybiBaseFramingOverhead = 2;
+const size_t kHybiMaskingKeyLength = 4;
+const size_t kMinimumPayloadSizeWithTwoByteExtendedPayloadLength = 126;
+const size_t kMinimumPayloadSizeWithEightByteExtendedPayloadLength = 0x10000;
+
+uint64_t SaturateAdd(uint64_t a, uint64_t b) {
+  if (kuint64max - a < b)
+    return kuint64max;
+  return a + b;
+}
+
+uint64_t GetFrameSize(uint64_t payload_size) {
+  if (!payload_size)
+    return 0;
+
+  uint64_t overhead = kHybiBaseFramingOverhead + kHybiMaskingKeyLength;
+  if (payload_size > kMinimumPayloadSizeWithEightByteExtendedPayloadLength)
+    overhead += 8;
+  else if (payload_size > kMinimumPayloadSizeWithTwoByteExtendedPayloadLength)
+    overhead += 2;
+  return SaturateAdd(payload_size, overhead);
+}
+
+}  // namespace
 
 namespace webkit {
 namespace ppapi {
 
 PPB_WebSocket_Impl::PPB_WebSocket_Impl(PP_Instance instance)
     : Resource(instance),
       state_(PP_WEBSOCKETREADYSTATE_INVALID_DEV),
       receive_callback_var_(NULL),
       wait_for_receive_(false),
       close_code_(0),
-      close_was_clean_(PP_FALSE) {
+      close_was_clean_(PP_FALSE),
+      buffered_amount_(0),
+      buffered_amount_after_close_(0) {
   empty_string_ = new StringVar(
       PpapiGlobals::Get()->GetModuleForInstance(instance), "", 0);
 }
 
 PPB_WebSocket_Impl::~PPB_WebSocket_Impl() {
   if (websocket_.get())
     websocket_->disconnect();
 
   // Clean up received and unread messages
   VarTracker* var_tracker = PpapiGlobals::Get()->GetVarTracker();
@@ skipping 176 matching lines @@
   if (!websocket_.get())
     return PP_ERROR_FAILED;
 
   // Check state.
   if (state_ == PP_WEBSOCKETREADYSTATE_INVALID_DEV ||
       state_ == PP_WEBSOCKETREADYSTATE_CONNECTING_DEV)
     return PP_ERROR_BADARGUMENT;
 
   if (state_ == PP_WEBSOCKETREADYSTATE_CLOSING_DEV ||
       state_ == PP_WEBSOCKETREADYSTATE_CLOSED_DEV) {
-    // TODO(toyoshim): Handle bufferedAmount here.
+    // Handle buffered_amount_after_close_.
+    uint64_t payload_size = 0;
+    if (message.type == PP_VARTYPE_STRING) {
+      scoped_refptr<StringVar> message_string = StringVar::FromPPVar(message);
+      if (message_string)
+        payload_size += message_string->value().length();
+    }
+    // TODO(toyoshim): Support binary data.
+
+    buffered_amount_after_close_ =
+        SaturateAdd(buffered_amount_after_close_, GetFrameSize(payload_size));
+
+    return PP_ERROR_FAILED;
   }
 
   if (message.type != PP_VARTYPE_STRING) {
     // TODO(toyoshim): Support binary data.
     return PP_ERROR_NOTSUPPORTED;
   }
 
   // Convert message to WebString.
   scoped_refptr<StringVar> message_string = StringVar::FromPPVar(message);
   if (!message_string)
     return PP_ERROR_BADARGUMENT;
   WebString web_message = WebString::fromUTF8(message_string->value());
   if (!websocket_->sendText(web_message))
     return PP_ERROR_BADARGUMENT;
 
   return PP_OK;
 }
 
 uint64_t PPB_WebSocket_Impl::GetBufferedAmount() {
-  // TODO(toyoshim): Implement.
-  return 0;
+  return SaturateAdd(buffered_amount_, buffered_amount_after_close_);
 }
 
 uint16_t PPB_WebSocket_Impl::GetCloseCode() {
   return close_code_;
 }
 
 PP_Var PPB_WebSocket_Impl::GetCloseReason() {
   if (!close_reason_)
     return empty_string_->GetPPVar();
   return close_reason_->GetPPVar();
@@ skipping 50 matching lines @@
 void PPB_WebSocket_Impl::didReceiveBinaryData(const WebData& binaryData) {
   DLOG(INFO) << "didReceiveBinaryData is not implemented yet.";
   // TODO(toyoshim): Support to receive binary data.
 }
 
 void PPB_WebSocket_Impl::didReceiveMessageError() {
   // TODO(toyoshim): Must implement.
   DLOG(INFO) << "didReceiveMessageError is not implemented yet.";
 }
 
-void PPB_WebSocket_Impl::didUpdateBufferedAmount(unsigned long bufferedAmount) {
-  // TODO(toyoshim): Must implement.
-  DLOG(INFO) << "didUpdateBufferedAmount is not implemented yet.";
+void PPB_WebSocket_Impl::didUpdateBufferedAmount(
+    unsigned long buffered_amount) {
+  if (state_ == PP_WEBSOCKETREADYSTATE_CLOSED_DEV)
+    return;
+  buffered_amount_ = buffered_amount;
 }
 
 void PPB_WebSocket_Impl::didStartClosingHandshake() {
   // TODO(toyoshim): Must implement.
   DLOG(INFO) << "didStartClosingHandshake is not implemented yet.";
 }
 
-void PPB_WebSocket_Impl::didClose(unsigned long bufferedAmount,
+void PPB_WebSocket_Impl::didClose(unsigned long buffered_amount,
                                   ClosingHandshakeCompletionStatus status,
                                   unsigned short code,
                                   const WebString& reason) {
   // Store code and reason.
   close_code_ = code;
   std::string reason_string = reason.utf8();
   close_reason_ = new StringVar(
       PpapiGlobals::Get()->GetModuleForInstance(pp_instance()), reason_string);
 
   // TODO(toyoshim): Set close_was_clean_.
 
   // Handle state transition and invoking callback.
   DCHECK_NE(PP_WEBSOCKETREADYSTATE_CLOSED_DEV, state_);
   PP_WebSocketReadyState_Dev state = state_;
   state_ = PP_WEBSOCKETREADYSTATE_CLOSED_DEV;
 
+  // Update buffered_amount_.
+  buffered_amount_ = buffered_amount;
+
   if (state == PP_WEBSOCKETREADYSTATE_CONNECTING_DEV)
     PP_RunAndClearCompletionCallback(&connect_callback_, PP_OK);
 
   if (state == PP_WEBSOCKETREADYSTATE_CLOSING_DEV)
     PP_RunAndClearCompletionCallback(&close_callback_, PP_OK);
 }
 
 int32_t PPB_WebSocket_Impl::DoReceive() {
   // TODO(toyoshim): Check state.
 
   if (!receive_callback_var_)
     return PP_OK;
 
   *receive_callback_var_ = received_messages_.front();
   received_messages_.pop();
   receive_callback_var_ = NULL;
   wait_for_receive_ = false;
   return PP_OK;
 }
 
 }  // namespace ppapi
 }  // namespace webkit