make SetReceiveBufferSize and SetSendBufferSize return net error codes (instead of bools)

remoting/protocol/fake_session.cc

 // Copyright (c) 2012 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 "remoting/protocol/fake_session.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "net/base/address_list.h"
 #include "net/base/io_buffer.h"
@@ skipping 118 matching lines @@
 
   if (peer_socket_.get()) {
     message_loop_->PostTask(
         FROM_HERE,
         base::Bind(&FakeSocket::AppendInputData,
                    peer_socket_,
                    std::vector<char>(buf->data(), buf->data() + buf_len)));
   }
 }
 
-bool FakeSocket::SetReceiveBufferSize(int32 size) {
+int FakeSocket::SetReceiveBufferSize(int32 size) {
   NOTIMPLEMENTED();
-  return false;
+  return net::ERR_NOT_IMPLEMENTED;
 }
-bool FakeSocket::SetSendBufferSize(int32 size) {
+
+int FakeSocket::SetSendBufferSize(int32 size) {
   NOTIMPLEMENTED();
-  return false;
+  return net::ERR_NOT_IMPLEMENTED;
 }
 
 int FakeSocket::Connect(const net::CompletionCallback& callback) {
   EXPECT_EQ(message_loop_, base::MessageLoop::current());
   return net::OK;
 }
 
 void FakeSocket::Disconnect() {
   peer_socket_.reset();
 }
 
 bool FakeSocket::IsConnected() const {
   EXPECT_EQ(message_loop_, base::MessageLoop::current());
   return true;
 }
 
 bool FakeSocket::IsConnectedAndIdle() const {
   NOTIMPLEMENTED();
   return false;
 }
 
 int FakeSocket::GetPeerAddress(net::IPEndPoint* address) const {
   net::IPAddressNumber ip(net::kIPv4AddressSize);
   *address = net::IPEndPoint(ip, 0);
   return net::OK;
 }
 
 int FakeSocket::GetLocalAddress(net::IPEndPoint* address) const {
   NOTIMPLEMENTED();
-  return net::ERR_FAILED;
+  return net::ERR_NOT_IMPLEMENTED;
 }
 
 const net::BoundNetLog& FakeSocket::NetLog() const {
   EXPECT_EQ(message_loop_, base::MessageLoop::current());
   return net_log_;
 }
 
 void FakeSocket::SetSubresourceSpeculation() {
   NOTIMPLEMENTED();
 }
@@ skipping 70 matching lines @@
 }
 
 int FakeUdpSocket::Write(net::IOBuffer* buf, int buf_len,
                          const net::CompletionCallback& callback) {
   EXPECT_EQ(message_loop_, base::MessageLoop::current());
   written_packets_.push_back(std::string());
   written_packets_.back().assign(buf->data(), buf->data() + buf_len);
   return buf_len;
 }
 
-bool FakeUdpSocket::SetReceiveBufferSize(int32 size) {
+int FakeUdpSocket::SetReceiveBufferSize(int32 size) {
   NOTIMPLEMENTED();
-  return false;
+  return net::ERR_NOT_IMPLEMENTED;
 }
-bool FakeUdpSocket::SetSendBufferSize(int32 size) {
+
+int FakeUdpSocket::SetSendBufferSize(int32 size) {
   NOTIMPLEMENTED();
-  return false;
+  return net::ERR_NOT_IMPLEMENTED;
 }
 
 FakeSession::FakeSession()
     : event_handler_(NULL),
       candidate_config_(CandidateSessionConfig::CreateDefault()),
       config_(SessionConfig::ForTest()),
       message_loop_(base::MessageLoop::current()),
       async_creation_(false),
       jid_(kTestJid),
       error_(OK),
@@ skipping 99 matching lines @@
     callback.Run(scoped_ptr<net::Socket>(datagram_channels_[name]));
 }
 
 void FakeSession::CancelChannelCreation(const std::string& name) {
   stream_channels_.erase(name);
   datagram_channels_.erase(name);
 }
 
 }  // namespace protocol
 }  // namespace remoting