DbxClientV1: Clean up IOException separation.

- Previously, we intercepted all HiddenExceptions.  Now, only intercept
  the instances that were thrown by our wrapper.
- Be more precise with our 'try' blocks to make sure the caller's
  exceptions get all the way through.

Author: Kannan Goundan

src/main/java/com/dropbox/core/NoThrowOutputStream.java

@@ -42,7 +42,7 @@ public void flush()
             underlying.flush();
         }
         catch (IOException ex) {
-            throw new HiddenException(ex);
+            throw new HiddenException(this, ex);
         }
     }
 
@@ -54,7 +54,7 @@ public void write(byte[] b, int off, int len)
             underlying.write(b, off, len);
         }
         catch (IOException ex) {
-            throw new HiddenException(ex);
+            throw new HiddenException(this, ex);
         }
     }
 
@@ -66,7 +66,7 @@ public void write(byte[] b)
             underlying.write(b);
         }
         catch (IOException ex) {
-            throw new HiddenException(ex);
+            throw new HiddenException(this, ex);
         }
     }
 
@@ -78,18 +78,24 @@ public void write(int b)
             underlying.write(b);
         }
         catch (IOException ex) {
-            throw new HiddenException(ex);
+            throw new HiddenException(this, ex);
         }
     }
 
     public static final class HiddenException extends RuntimeException
     {
-        public final IOException underlying;
+        public final NoThrowOutputStream owner;
 
-        public HiddenException(IOException underlying)
+        public HiddenException(NoThrowOutputStream owner, IOException underlying)
         {
             super(underlying);
-            this.underlying = underlying;
+            this.owner = owner;
+        }
+
+        @Override
+        public IOException getCause()
+        {
+            return (IOException) super.getCause();
         }
 
         public static final long serialVersionUID = 0;

src/main/java/com/dropbox/core/v1/DbxClientV1.java

@@ -718,10 +718,8 @@ public <E extends Throwable> DbxEntry.File finishUploadFile(Uploader uploader, D
             return uploader.finish();
         }
         catch (NoThrowOutputStream.HiddenException ex) {
-            // We hid our OutputStream's IOException from their writer.write() function so that
-            // we could properly raise a NetworkIOException if something went wrong with the
-            // network stream.
-            throw new NetworkIOException(ex.underlying);
+            if (ex.owner == streamWrapper) throw new NetworkIOException(ex.getCause());
+            throw ex;
         }
         finally {
             uploader.close();
@@ -940,21 +938,29 @@ private <E extends Throwable> HttpRequestor.Response chunkedUploadCommon(String[
 
         HttpRequestor.Uploader uploader = DbxRequestUtil.startPut(requestConfig, accessToken, USER_AGENT_ID, host.getContent(), apiPath, params, headers);
         try {
+            NoThrowOutputStream nt = new NoThrowOutputStream(uploader.getBody());
             try {
-                NoThrowOutputStream nt = new NoThrowOutputStream(uploader.getBody());
+                // Any exceptions thrown by writer.write (e.g. IOException) are "owned" by
+                // the caller so let them propagate.  We should only handle exceptions caused
+                // by our uploader OutputStream.
                 writer.write(nt);
-                long bytesWritten = nt.getBytesWritten();
-                if (bytesWritten != chunkSize) {
-                    throw new IllegalStateException("'chunkSize' is " + chunkSize + ", but 'writer' only wrote " + bytesWritten + " bytes");
-                }
+            }
+            catch (NoThrowOutputStream.HiddenException ex) {
+                if (ex.owner == nt) throw new NetworkIOException(ex.getCause());
+                throw ex;
+            }
+
+            long bytesWritten = nt.getBytesWritten();
+            if (bytesWritten != chunkSize) {
+                throw new IllegalStateException("'chunkSize' is " + chunkSize + ", but 'writer' only wrote " + bytesWritten + " bytes");
+            }
+
+            try {
                 return uploader.finish();
             }
             catch (IOException ex) {
                 throw new NetworkIOException(ex);
             }
-            catch (NoThrowOutputStream.HiddenException ex) {
-                throw new NetworkIOException(ex.underlying);
-            }
         }
         finally {
             uploader.close();