Update error-handling logic in ChromiumPacketSocketFactory.

remoting/jingle_glue/chromium_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/jingle_glue/chromium_socket_factory.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "jingle/glue/utils.h"
@@ skipping 10 matching lines @@
 
 // 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;
 
-// Defines set of transient errors. These errors are ignored when we get them
-// from sendto() calls.
-bool IsTransientError(int error) {
-  return error == net::ERR_ADDRESS_UNREACHABLE ||
-      error == net::ERR_ADDRESS_INVALID;
+// 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 true if |error| must be ignored when returned from sendto(). |retry|
+// is set set when sentto() should be called for the same packet again.
+//
+// Keep this logic in sync with GetErrorAction() in
+// remoting/client/plugin/pepper_packet_socket_factory.cc .
+ErrorAction GetErrorAction(int error) {
+  switch (error) {
+    // UDP is connectionless, so we may receive ICMP unreachable or reset errors
+    // for previous sends to different addresses.
+    case net::ERR_ADDRESS_UNREACHABLE:
+    case net::ERR_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 net::ERR_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.
+    case net::ERR_ACCESS_DENIED:
+      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 net::ERR_OUT_OF_MEMORY:
+      return ERROR_ACTION_IGNORE;
+
+    default:
+      return ERROR_ACTION_FAIL;
+  }
 }
 
 class UdpPacketSocket : public talk_base::AsyncPacketSocket {
  public:
   UdpPacketSocket();
   virtual ~UdpPacketSocket();
 
   bool Init(const talk_base::SocketAddress& local_address,
             int min_port, int max_port);
 
@@ skipping 13 matching lines @@
   virtual void SetError(int error) OVERRIDE;
 
  private:
   struct PendingPacket {
     PendingPacket(const void* buffer,
                   int buffer_size,
                   const net::IPEndPoint& address);
 
     scoped_refptr<net::IOBufferWithSize> data;
     net::IPEndPoint address;
+    bool retried;
   };
 
   void OnBindCompleted(int error);
 
   void DoSend();
   void OnSendCompleted(int result);
 
   void DoRead();
   void OnReadCompleted(int result);
   void HandleReadResult(int result);
@@ skipping 14 matching lines @@
   int send_queue_size_;
 
   DISALLOW_COPY_AND_ASSIGN(UdpPacketSocket);
 };
 
 UdpPacketSocket::PendingPacket::PendingPacket(
     const void* buffer,
     int buffer_size,
     const net::IPEndPoint& address)
     : data(new net::IOBufferWithSize(buffer_size)),
-      address(address) {
+      address(address),
+      retried(false) {
   memcpy(data->data(), buffer, buffer_size);
 }
 
 UdpPacketSocket::UdpPacketSocket()
     : state_(STATE_CLOSED),
       error_(0),
       send_pending_(false),
       send_queue_size_(0) {
 }
 
@@ skipping 164 matching lines @@
     send_pending_ = true;
   } else {
     OnSendCompleted(result);
   }
 }
 
 void UdpPacketSocket::OnSendCompleted(int result) {
   send_pending_ = false;
 
   if (result < 0) {
-    if (!IsTransientError(result)) {
-      LOG(ERROR) << "Send failed on a UDP socket: " << result;
-      error_ = EINVAL;
-      return;
+    ErrorAction action = GetErrorAction(result);
+    switch (action) {
+      case ERROR_ACTION_FAIL:
+        LOG(ERROR) << "Send failed on a UDP socket: " << result;
+        error_ = EINVAL;
+        return;
+
+      case ERROR_ACTION_RETRY:
+        // Retry resending only once.
+        if (!send_queue_.front().retried) {
+          send_queue_.front().retried = true;
+          DoSend();
+          return;
+        }
+        break;
+
+      case ERROR_ACTION_IGNORE:
+        break;
     }
   }
 
   // Don't need to worry about partial sends because this is a datagram
   // socket.
   send_queue_size_ -= send_queue_.front().data->size();
   send_queue_.pop_front();
   DoSend();
 }
 
@@ skipping 74 matching lines @@
   NOTREACHED();
   return NULL;
 }
 
 talk_base::AsyncResolverInterface*
 ChromiumPacketSocketFactory::CreateAsyncResolver() {
   return new talk_base::AsyncResolver();
 }
 
 }  // namespace remoting