Add SetProperty() in the PPB_Transport_Dev interface.

webkit/plugins/ppapi/ppb_transport_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_transport_impl.h"
 
+#include "base/json/json_reader.h"
+#include "base/json/json_writer.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
+#include "base/values.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/socket/socket.h"
 #include "ppapi/c/dev/ppb_transport_dev.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/shared_impl/var.h"
 #include "webkit/plugins/ppapi/common.h"
 #include "webkit/plugins/ppapi/plugin_module.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 
 using ppapi::StringVar;
 using ppapi::thunk::PPB_Transport_API;
 using webkit_glue::P2PTransport;
 
 namespace webkit {
 namespace ppapi {
 
 namespace {
 
 const char kUdpProtocolName[] = "udp";
 const char kTcpProtocolName[] = "tcp";
 
+const int kMinBufferSize = 1024;
+const int kMaxBufferSize = 1024 * 1024;
+
 int MapNetError(int result) {
   if (result > 0)
     return result;
 
   switch (result) {
     case net::OK:
       return PP_OK;
     case net::ERR_IO_PENDING:
       return PP_OK_COMPLETIONPENDING;
     case net::ERR_INVALID_ARGUMENT:
@@ skipping 48 matching lines @@
   return p2p_transport_.get() != NULL;
 }
 
 PP_Bool PPB_Transport_Impl::IsWritable() {
   if (!p2p_transport_.get())
     return PP_FALSE;
 
   return PP_FromBool(writable_);
 }
 
+const char kStringListSeparator = ',';

[brettw, 2011/08/25 16:48:43]

It doesn't look like you use this.

[Sergey Ulanov, 2011/08/25 17:36:53]

Done.

+
+int32_t PPB_Transport_Impl::SetProperty(PP_TransportProperty property,
+                                        PP_Var value) {
+  // SetProperty() may be called only before Connect().
+  if (started_)
+    return PP_ERROR_FAILED;
+
+  switch (property) {
+    case PP_TRANSPORTPROPERTY_STUN_SERVER: {
+      StringVar* value_str = StringVar::FromPPVar(value);
+      if (!value_str)
+        return PP_ERROR_BADARGUMENT;
+      config_.stun_server = value_str->value();
+      break;
+    }
+
+    case PP_TRANSPORTPROPERTY_RELAY_SERVER: {
+      StringVar* value_str = StringVar::FromPPVar(value);
+      if (!value_str)
+        return PP_ERROR_BADARGUMENT;
+      config_.relay_server = value_str->value();
+      break;
+    }
+
+    case PP_TRANSPORTPROPERTY_RELAY_TOKEN: {
+      StringVar* value_str = StringVar::FromPPVar(value);
+      if (!value_str)
+        return PP_ERROR_BADARGUMENT;
+      config_.relay_token = value_str->value();
+      break;
+    }
+
+    case PP_TRANSPORTPROPERTY_TCP_RECEIVE_WINDOW: {
+      if (!use_tcp_)
+        return PP_ERROR_BADARGUMENT;
+
+      int32_t int_value = value.value.as_int;
+      if (value.type != PP_VARTYPE_INT32 || int_value < kMinBufferSize ||
+          int_value > kMaxBufferSize) {
+        return PP_ERROR_BADARGUMENT;
+      }
+      config_.tcp_receive_window = int_value;
+      break;
+    }
+
+    case PP_TRANSPORTPROPERTY_TCP_SEND_WINDOW: {
+      if (!use_tcp_)
+        return PP_ERROR_BADARGUMENT;
+
+      int32_t int_value = value.value.as_int;
+      if (value.type != PP_VARTYPE_INT32 || int_value < kMinBufferSize ||
+          int_value > kMaxBufferSize) {
+        return PP_ERROR_BADARGUMENT;
+      }
+      config_.tcp_send_window = int_value;
+      break;
+    }
+
+    default:
+      return PP_ERROR_BADARGUMENT;
+  };

[brettw, 2011/08/25 16:48:43]

Don't think you need the ;

[Sergey Ulanov, 2011/08/25 17:36:53]

Done.

+
+  return PP_OK;
+}
+
 int32_t PPB_Transport_Impl::Connect(PP_CompletionCallback callback) {
   if (!p2p_transport_.get())
     return PP_ERROR_FAILED;
 
   // Connect() has already been called.
   if (started_)
     return PP_ERROR_INPROGRESS;
 
   P2PTransport::Protocol protocol = use_tcp_ ?
       P2PTransport::PROTOCOL_TCP : P2PTransport::PROTOCOL_UDP;
 
-  if (!p2p_transport_->Init(name_, protocol, "", this))
+  if (!p2p_transport_->Init(name_, protocol, config_, this))
     return PP_ERROR_FAILED;
 
   started_ = true;
 
   connect_callback_ = new TrackedCompletionCallback(
       instance()->module()->GetCallbackTracker(), pp_resource(), callback);
   return PP_OK_COMPLETIONPENDING;
 }
 
 int32_t PPB_Transport_Impl::GetNextAddress(PP_Var* address,
@@ skipping 124 matching lines @@
 void PPB_Transport_Impl::OnWritten(int result) {
   DCHECK(send_callback_.get() && !send_callback_->completed());
 
   scoped_refptr<TrackedCompletionCallback> callback;
   callback.swap(send_callback_);
   callback->Run(MapNetError(result));
 }
 
 }  // namespace ppapi
 }  // namespace webkit