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"
@@ skipping 19 matching lines @@
       return PP_OK;
     case net::ERR_IO_PENDING:
       return PP_OK_COMPLETIONPENDING;
     case net::ERR_INVALID_ARGUMENT:
       return PP_ERROR_BADARGUMENT;
     default:
       return PP_ERROR_FAILED;
   }
 }
 
+std::string FormatJson(Value* value) {
+  std::string result;
+  base::JSONWriter::Write(value, false, &result);
+  return result;
+}
+
+// ParseConfig() parses JSON blob with P2P Transport
+// configuration. Example of a valid config:
+//  {
+//     "stunServer": ["stun1.l.google.com:31323", "stun2.l.google.com:54324"],
+//     "relayServer": "relay.google.com",
+//     "relayToken": "34t34f234f12",
+//     "tcpReceiveWindow": 32768,
+//     "tcpSendWindow": 32768,
+//  };
+int ParseConfig(const std::string& config_str, P2PTransport::Config* config) {
+  scoped_ptr<Value> value(base::JSONReader::Read(config_str, true));
+  if (!value.get() || !value->IsType(Value::TYPE_DICTIONARY)) {
+    return false;
+  }
+
+  DictionaryValue* dic_value = static_cast<DictionaryValue*>(value.get());
+
+  // Parse STUN servers list.
+  config->stun_servers.clear();
+  Value* stun_server;
+  if (dic_value->Get("stunServer", &stun_server)) {
+    if (stun_server->IsType(Value::TYPE_LIST)) {
+      ListValue* stun_list = static_cast<ListValue*>(stun_server);
+      for (ListValue::iterator it = stun_list->begin();
+           it != stun_list->end(); ++it) {
+        std::string server_address;
+        if ((*it)->GetAsString(&server_address)) {
+          config->stun_servers.push_back(server_address);
+        } else {
+          LOG(ERROR) << "Invalid stun server specification: " <<
+              FormatJson(*it);
+          return false;
+        }
+      }
+    } else if (stun_server->IsType(Value::TYPE_STRING)) {
+      std::string server_address;
+      stun_server->GetAsString(&server_address);
+      config->stun_servers.push_back(server_address);
+    } else {
+      LOG(ERROR) << "Invalid stun server specification: "
+                 << FormatJson(stun_server);
+      return false;
+    }
+  }
+
+  // Parse Relay servers list.
+  config->relay_servers.clear();
+  Value* relay_server;
+  if (dic_value->Get("relayServer", &relay_server)) {
+    if (relay_server->IsType(Value::TYPE_LIST)) {
+      ListValue* relay_list = static_cast<ListValue*>(relay_server);
+      for (ListValue::iterator it = relay_list->begin();
+           it != relay_list->end(); ++it) {
+        std::string server_address;
+        if ((*it)->GetAsString(&server_address)) {
+          config->relay_servers.push_back(server_address);
+        } else {
+          LOG(ERROR) << "Invalid relay server specification: "
+                     << FormatJson(*it);
+          return false;
+        }
+      }
+    } else if (relay_server->IsType(Value::TYPE_STRING)) {
+      std::string server_address;
+      relay_server->GetAsString(&server_address);
+      config->relay_servers.push_back(server_address);
+    } else {
+      LOG(ERROR) << "Invalid relay server specification: "
+                 << FormatJson(relay_server);
+      return false;
+    }
+  }
+
+  // Relay token.
+  Value* relay_token;
+  if (dic_value->Get("relayToken", &relay_token)) {
+    if (!relay_token->GetAsString(&config->relay_token)) {
+      LOG(ERROR) << "Invalid relay token: "
+                 << FormatJson(relay_token);
+      return false;
+    }
+  } else {
+    config->relay_token = "";
+  }
+
+  Value* tcp_receive_window;
+  if (dic_value->Get("tcpReceiveWindow", &tcp_receive_window)) {
+    if (!tcp_receive_window->GetAsInteger(&config->tcp_receive_window)) {
+      LOG(ERROR) << "Invalid TCP receive window value: "
+                 << FormatJson(tcp_receive_window);
+      return false;
+    }
+  } else {
+    config->tcp_receive_window = 0;
+  }
+
+  Value* tcp_send_window;
+  if (dic_value->Get("tcpSendWindow", &tcp_send_window)) {
+    if (!tcp_send_window->GetAsInteger(&config->tcp_send_window)) {
+      LOG(ERROR) << "Invalid TCP send window value: "
+                 << FormatJson(tcp_send_window);
+      return false;
+    }
+  } else {
+    config->tcp_send_window = 0;
+  }
+
+  return true;
+}
+
 }  // namespace
 
 PPB_Transport_Impl::PPB_Transport_Impl(PluginInstance* instance)
     : Resource(instance),
       started_(false),
       writable_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           channel_write_callback_(this, &PPB_Transport_Impl::OnWritten)),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           channel_read_callback_(this, &PPB_Transport_Impl::OnRead)) {
@@ skipping 32 matching lines @@
   return p2p_transport_.get() != NULL;
 }
 
 PP_Bool PPB_Transport_Impl::IsWritable() {
   if (!p2p_transport_.get())
     return PP_FALSE;
 
   return PP_FromBool(writable_);
 }
 
+int32_t PPB_Transport_Impl::SetConfig(const char* config) {
+  // SetConfig() may only be called before Connect().
+  if (started_)
+    return PP_ERROR_FAILED;
+
+  return ParseConfig(config, &config_) ? PP_OK : PP_ERROR_BADARGUMENT;
+}
+
 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