Unbranch libjingle

jingle/glue/fake_socket_factory.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 "jingle/glue/fake_socket_factory.h"
 
 #include "base/message_loop.h"
 #include "jingle/glue/utils.h"
 #include "third_party/libjingle/source/talk/base/asyncsocket.h"
 
 namespace jingle_glue {
 
 FakeUDPPacketSocket::FakeUDPPacketSocket(FakeSocketManager* fake_socket_manager,
                                          const net::IPEndPoint& address)
     : fake_socket_manager_(fake_socket_manager),
-      endpoint_(address), state_(STATE_OPEN), error_(0) {
+      endpoint_(address), state_(IS_OPEN), error_(0) {
   CHECK(IPEndPointToSocketAddress(endpoint_, &local_address_));
   fake_socket_manager_->AddSocket(this);
 }
 
 FakeUDPPacketSocket::~FakeUDPPacketSocket() {
   fake_socket_manager_->RemoveSocket(this);
 }
 
-bool FakeUDPPacketSocket::GetLocalAddress(
-    talk_base::SocketAddress* address) const {
+talk_base::SocketAddress FakeUDPPacketSocket::GetLocalAddress() const {
   DCHECK(CalledOnValidThread());
-  *address = local_address_;
-  return true;
+  return local_address_;
 }
 
 talk_base::SocketAddress FakeUDPPacketSocket::GetRemoteAddress() const {
   DCHECK(CalledOnValidThread());
   return remote_address_;
 }
 
 int FakeUDPPacketSocket::Send(const void *data, size_t data_size) {
   DCHECK(CalledOnValidThread());
   return SendTo(data, data_size, remote_address_);
 }
 
 int FakeUDPPacketSocket::SendTo(const void *data, size_t data_size,
                                 const talk_base::SocketAddress& address) {
   DCHECK(CalledOnValidThread());
 
-  if (state_ == STATE_CLOSED) {
+  if (state_ == IS_CLOSED) {
     return ENOTCONN;
   }
 
   net::IPEndPoint destination;
   if (!SocketAddressToIPEndPoint(address, &destination)) {
     return EINVAL;
   }
 
   const char* data_char = reinterpret_cast<const char*>(data);
   std::vector<char> data_vector(data_char, data_char + data_size);
 
   fake_socket_manager_->SendPacket(endpoint_, destination, data_vector);
 
   return data_size;
 }
 
 int FakeUDPPacketSocket::Close() {
   DCHECK(CalledOnValidThread());
-  state_ = STATE_CLOSED;
+  state_ = IS_CLOSED;
   return 0;
 }
 
-talk_base::Socket::ConnState FakeUDPPacketSocket::GetState() const {
+talk_base::AsyncPacketSocket::State FakeUDPPacketSocket::GetState() const {
   DCHECK(CalledOnValidThread());
 
   switch (state_) {
-    case STATE_OPEN:
-      return talk_base::Socket::CS_CONNECTED;
-    case STATE_CLOSED:
-      return talk_base::Socket::CS_CLOSED;
+    case IS_OPEN:
+      return STATE_BOUND;
+    case IS_CLOSED:
+      return STATE_CLOSED;
   }
 
   NOTREACHED();
-  return talk_base::Socket::CS_CLOSED;
+  return STATE_CLOSED;
 }
 
 int FakeUDPPacketSocket::GetOption(talk_base::Socket::Option opt, int* value) {
   DCHECK(CalledOnValidThread());
   return -1;
 }
 
 int FakeUDPPacketSocket::SetOption(talk_base::Socket::Option opt, int value) {
   DCHECK(CalledOnValidThread());
   return -1;
@@ skipping 97 matching lines @@
     const talk_base::SocketAddress& local_address,
     const talk_base::SocketAddress& remote_address,
     const talk_base::ProxyInfo& proxy_info, const std::string& user_agent,
     bool ssl) {
   // TODO(sergeyu): Implement fake TCP sockets.
   NOTIMPLEMENTED();
   return NULL;
 }
 
 }  // namespace jingle_glue