Update error-handling logic in ChromiumPacketSocketFactory.

remoting/client/plugin/pepper_packet_socket_factory.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/client/plugin/pepper_packet_socket_factory.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "net/base/io_buffer.h"
+#include "net/base/net_errors.h"
 #include "ppapi/cpp/net_address.h"
 #include "ppapi/cpp/udp_socket.h"
 #include "ppapi/utility/completion_callback_factory.h"
 #include "remoting/client/plugin/pepper_util.h"
+#include "remoting/jingle_glue/socket_util.h"
 #include "third_party/libjingle/source/talk/base/asyncpacketsocket.h"
 
 namespace remoting {
 
 namespace {
 
 // Size of the buffer to allocate for RecvFrom().
 const int kReceiveBufferSize = 65536;
 
 // Maximum amount of data in the send buffers. This is necessary to
 // prevent out-of-memory crashes if the caller sends data faster than
 // Pepper's UDP API can handle it. This maximum should never be
 // reached under normal conditions.
 const int kMaxSendBufferSize = 256 * 1024;
 
-// Enum for different actions that can be taken after sendto() returns an error.
-enum ErrorAction {
-  ERROR_ACTION_FAIL,
-  ERROR_ACTION_IGNORE,
-  ERROR_ACTION_RETRY,
-};
-
-// Returns ErrorAction to perform if sendto() fails with |error|.
-ErrorAction GetErrorAction(int error) {
+int PepperErrorToNetError(int error) {

[Wez, 2014/06/17 22:39:21]

nit: Could this go into e.g. pepper_util.h?

[Sergey Ulanov, 2014/06/17 22:45:01]

I don't think it's necessary because it's specific to this file right now, and
it won't be useful for most pepper APIs anyway. We can always move it later,
when it becomes necessary to share it.

   switch (error) {
-    // UDP is connectionless, so we may receive ICMP unreachable or reset errors
-    // for previous sends to different addresses.
+    case PP_OK:
+      return net::OK;
+    case PP_OK_COMPLETIONPENDING:
+      return net::ERR_IO_PENDING;
+    case PP_ERROR_ABORTED:
+      return net::ERR_ABORTED;
+    case PP_ERROR_BADARGUMENT:
+      return net::ERR_INVALID_ARGUMENT;
+    case PP_ERROR_FILENOTFOUND:
+      return net::ERR_FILE_NOT_FOUND;
+    case PP_ERROR_TIMEDOUT:
+      return net::ERR_TIMED_OUT;
+    case PP_ERROR_FILETOOBIG:
+      return net::ERR_FILE_TOO_BIG;
+    case PP_ERROR_NOTSUPPORTED:
+      return net::ERR_NOT_IMPLEMENTED;
+    case PP_ERROR_NOMEMORY:
+      return net::ERR_OUT_OF_MEMORY;
+    case PP_ERROR_FILEEXISTS:
+      return net::ERR_FILE_EXISTS;
+    case PP_ERROR_NOSPACE:
+      return net::ERR_FILE_NO_SPACE;
+    case PP_ERROR_CONNECTION_CLOSED:
+      return net::ERR_CONNECTION_CLOSED;
+    case PP_ERROR_CONNECTION_RESET:
+      return net::ERR_CONNECTION_RESET;
+    case PP_ERROR_CONNECTION_REFUSED:
+      return net::ERR_CONNECTION_REFUSED;
+    case PP_ERROR_CONNECTION_ABORTED:
+      return net::ERR_CONNECTION_ABORTED;
+    case PP_ERROR_CONNECTION_FAILED:
+      return net::ERR_CONNECTION_FAILED;
+    case PP_ERROR_NAME_NOT_RESOLVED:
+      return net::ERR_NAME_NOT_RESOLVED;
+    case PP_ERROR_ADDRESS_INVALID:
+      return net::ERR_ADDRESS_INVALID;
     case PP_ERROR_ADDRESS_UNREACHABLE:
-    case PP_ERROR_CONNECTION_RESET:
-      return ERROR_ACTION_RETRY;
-
-    // Target address is invalid. The socket is still usable for different
-    // target addresses and the error can be ignored.
-    case PP_ERROR_ADDRESS_INVALID:
-      return ERROR_ACTION_IGNORE;
-
-    // May be returned when the packet is blocked by local firewall (see
-    // https://code.google.com/p/webrtc/issues/detail?id=1207). The firewall may
-    // still allow us to send to other addresses, so ignore the error for this
-    // particular send.
+      return net::ERR_ADDRESS_UNREACHABLE;
+    case PP_ERROR_CONNECTION_TIMEDOUT:
+      return net::ERR_CONNECTION_TIMED_OUT;
     case PP_ERROR_NOACCESS:
-      return ERROR_ACTION_IGNORE;
-
-    // Indicates that the buffer in the network adapter is full, so drop this
-    // packet and assume the socket is still usable.
-    case PP_ERROR_NOMEMORY:
-      return ERROR_ACTION_IGNORE;
-
+      return net::ERR_NETWORK_ACCESS_DENIED;
+    case PP_ERROR_MESSAGE_TOO_BIG:
+      return net::ERR_MSG_TOO_BIG;
+    case PP_ERROR_ADDRESS_IN_USE:
+      return net::ERR_ADDRESS_IN_USE;
     default:
-      return ERROR_ACTION_FAIL;
+      return net::ERR_FAILED;
   }
 }
 
 class UdpPacketSocket : public talk_base::AsyncPacketSocket {
  public:
   explicit UdpPacketSocket(const pp::InstanceHandle& instance);
   virtual ~UdpPacketSocket();
 
   // |min_port| and |max_port| are set to zero if the port number
   // should be assigned by the OS.
@@ skipping 241 matching lines @@
   if (result == PP_ERROR_ABORTED) {
     // Send is aborted when the socket is being destroyed.
     // |send_queue_| may be already destroyed, it's not safe to access
     // it here.
     return;
   }
 
   send_pending_ = false;
 
   if (result < 0) {
-    ErrorAction action = GetErrorAction(result);
+    int net_error = PepperErrorToNetError(result);
+    SocketErrorAction action = GetSocketErrorAction(net_error);
     switch (action) {
-      case ERROR_ACTION_FAIL:
+      case SOCKET_ERROR_ACTION_FAIL:
         LOG(ERROR) << "Send failed on a UDP socket: " << result;
         error_ = EINVAL;
         return;
 
-      case ERROR_ACTION_RETRY:
+      case SOCKET_ERROR_ACTION_RETRY:
         // Retry resending only once.
         if (!send_queue_.front().retried) {
           send_queue_.front().retried = true;
           DoSend();
           return;
         }
         break;
 
-      case ERROR_ACTION_IGNORE:
+      case SOCKET_ERROR_ACTION_IGNORE:
         break;
     }
   }
 
   send_queue_size_ -= send_queue_.front().data->size();
   send_queue_.pop_front();
   DoSend();
 }
 
 void UdpPacketSocket::DoRead() {
   receive_buffer_.resize(kReceiveBufferSize);
   pp::CompletionCallbackWithOutput<pp::NetAddress> callback =
       callback_factory_.NewCallbackWithOutput(
           &UdpPacketSocket::OnReadCompleted);
   int result =
       socket_.RecvFrom(&receive_buffer_[0], receive_buffer_.size(), callback);
   DCHECK_EQ(result, PP_OK_COMPLETIONPENDING);
 }
 
 void UdpPacketSocket::OnReadCompleted(int result, pp::NetAddress address) {
   HandleReadResult(result, address);
   if (result > 0) {
     DoRead();
   }
 }
 
-  void UdpPacketSocket::HandleReadResult(int result, pp::NetAddress address) {
+void UdpPacketSocket::HandleReadResult(int result, pp::NetAddress address) {
   if (result > 0) {
     talk_base::SocketAddress socket_address;
     PpNetAddressToSocketAddress(address, &socket_address);
     SignalReadPacket(this, &receive_buffer_[0], result, socket_address,
                      talk_base::CreatePacketTime(0));
   } else if (result != PP_ERROR_ABORTED) {
     LOG(ERROR) << "Received error when reading from UDP socket: " << result;
   }
 }
 
@@ skipping 38 matching lines @@
   return NULL;
 }
 
 talk_base::AsyncResolverInterface*
 PepperPacketSocketFactory::CreateAsyncResolver() {
   NOTREACHED();
   return NULL;
 }
 
 }  // namespace remoting