mojo/services/network/net_adapters.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "mojo/services/network/net_adapters.h"
   6
   7 #include "net/base/net_errors.h"
   8
   9 namespace mojo {
  10
  11 namespace {
  12
  13 const uint32_t kMaxBufSize = 64 * 1024;
  14
  15 }  // namespace
  16
  17 NetToMojoPendingBuffer::NetToMojoPendingBuffer(
  18     ScopedDataPipeProducerHandle handle,
  19     void* buffer)
  20     : handle_(handle.Pass()),
  21       buffer_(buffer) {
  22 }
  23
  24 NetToMojoPendingBuffer::~NetToMojoPendingBuffer() {
  25   if (handle_.is_valid())
  26     EndWriteDataRaw(handle_.get(), 0);
  27 }
  28
  29 // static
  30 MojoResult NetToMojoPendingBuffer::BeginWrite(
  31     ScopedDataPipeProducerHandle* handle,
  32     scoped_refptr<NetToMojoPendingBuffer>* pending,
  33     uint32_t* num_bytes) {
  34   void* buf;
  35   *num_bytes = 0;
  36
  37   MojoResult result = BeginWriteDataRaw(handle->get(), &buf, num_bytes,
  38                                         MOJO_WRITE_DATA_FLAG_NONE);
  39   if (result == MOJO_RESULT_OK) {
  40     if (*num_bytes > kMaxBufSize)
  41       *num_bytes = kMaxBufSize;
  42     *pending = new NetToMojoPendingBuffer(handle->Pass(), buf);
  43   }
  44   return result;
  45 }
  46
  47 ScopedDataPipeProducerHandle NetToMojoPendingBuffer::Complete(
  48     uint32_t num_bytes) {
  49   EndWriteDataRaw(handle_.get(), num_bytes);
  50   buffer_ = NULL;
  51   return handle_.Pass();
  52 }
  53
  54 // -----------------------------------------------------------------------------
  55
  56 NetToMojoIOBuffer::NetToMojoIOBuffer(
  57     NetToMojoPendingBuffer* pending_buffer)
  58     : net::WrappedIOBuffer(pending_buffer->buffer()),
  59       pending_buffer_(pending_buffer) {
  60 }
  61
  62 NetToMojoIOBuffer::~NetToMojoIOBuffer() {
  63 }
  64
  65 // -----------------------------------------------------------------------------
  66
  67 MojoToNetPendingBuffer::MojoToNetPendingBuffer(
  68     ScopedDataPipeConsumerHandle handle,
  69     const void* buffer)
  70     : handle_(handle.Pass()),
  71       buffer_(buffer) {
  72 }
  73
  74 MojoToNetPendingBuffer::~MojoToNetPendingBuffer() {
  75 }
  76
  77 // static
  78 MojoResult MojoToNetPendingBuffer::BeginRead(
  79     ScopedDataPipeConsumerHandle* handle,
  80     scoped_refptr<MojoToNetPendingBuffer>* pending,
  81     uint32_t* num_bytes) {
  82   const void* buffer = NULL;
  83   *num_bytes = 0;
  84   MojoResult result = BeginReadDataRaw(handle->get(), &buffer, num_bytes,
  85                                        MOJO_READ_DATA_FLAG_NONE);
  86   if (result == MOJO_RESULT_OK)
  87     *pending = new MojoToNetPendingBuffer(handle->Pass(), buffer);
  88   return result;
  89 }
  90
  91 ScopedDataPipeConsumerHandle MojoToNetPendingBuffer::Complete(
  92     uint32_t num_bytes) {
  93   EndReadDataRaw(handle_.get(), num_bytes);
  94   buffer_ = NULL;
  95   return handle_.Pass();
  96 }
  97
  98 // -----------------------------------------------------------------------------
  99
 100 MojoToNetIOBuffer::MojoToNetIOBuffer(MojoToNetPendingBuffer* pending_buffer)
 101     : net::WrappedIOBuffer(pending_buffer->buffer()),
 102       pending_buffer_(pending_buffer) {
 103 }
 104
 105 MojoToNetIOBuffer::~MojoToNetIOBuffer() {
 106 }
 107
 108 // -----------------------------------------------------------------------------
 109
 110 NetworkErrorPtr MakeNetworkError(int error_code) {
 111   NetworkErrorPtr error = NetworkError::New();
 112   error->code = error_code;
 113   if (error_code <= 0)
 114     error->description = net::ErrorToString(error_code);
 115   return error.Pass();
 116 }
 117
 118 }  // namespace mojo