Remove NSInputStream used in HTTPTransportMac and use a CFReadStream instead.

util/net/http_transport_mac.mm

 // Copyright 2014 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "util/net/http_transport.h"
 
+#include <CoreFoundation/CoreFoundation.h>
 #import <Foundation/Foundation.h>
 
 #include "base/mac/foundation_util.h"
 #import "base/mac/scoped_nsobject.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "util/net/http_body.h"
-
-@interface CrashpadHTTPBodyStreamTransport : NSInputStream {
- @private
-  NSStreamStatus streamStatus_;
-  id<NSStreamDelegate> delegate_;
-  crashpad::HTTPBodyStream* bodyStream_;  // weak
-}
-- (instancetype)initWithBodyStream:(crashpad::HTTPBodyStream*)bodyStream;
-@end
-
-@implementation CrashpadHTTPBodyStreamTransport
-
-- (instancetype)initWithBodyStream:(crashpad::HTTPBodyStream*)bodyStream {
-  if ((self = [super init])) {
-    streamStatus_ = NSStreamStatusNotOpen;
-    bodyStream_ = bodyStream;
-  }
-  return self;
-}
-
-// NSInputStream:
-
-- (BOOL)hasBytesAvailable {
-  // Per Apple's documentation: "May also return YES if a read must be attempted
-  // in order to determine the availability of bytes."
-  switch (streamStatus_) {
-    case NSStreamStatusAtEnd:
-    case NSStreamStatusClosed:
-    case NSStreamStatusError:
-      return NO;
-    default:
-      return YES;
-  }
-}
-
-- (NSInteger)read:(uint8_t*)buffer maxLength:(NSUInteger)maxLen {
-  streamStatus_ = NSStreamStatusReading;
-
-  NSInteger rv = bodyStream_->GetBytesBuffer(buffer, maxLen);
-
-  if (rv == 0)
-    streamStatus_ = NSStreamStatusAtEnd;
-  else if (rv < 0)
-    streamStatus_ = NSStreamStatusError;
-  else
-    streamStatus_ = NSStreamStatusOpen;
-
-  return rv;
-}
-
-- (BOOL)getBuffer:(uint8_t**)buffer length:(NSUInteger*)length {
-  return NO;
-}
-
-// NSStream:
-
-- (void)scheduleInRunLoop:(NSRunLoop*)runLoop
-                  forMode:(NSString*)mode {
-}
-
-- (void)removeFromRunLoop:(NSRunLoop*)runLoop
-                  forMode:(NSString*)mode {
-}
-
-- (void)open {
-  streamStatus_ = NSStreamStatusOpen;
-}
-
-- (void)close {
-  streamStatus_ = NSStreamStatusClosed;
-}
-
-- (NSStreamStatus)streamStatus {
-  return streamStatus_;
-}
-
-- (id<NSStreamDelegate>)delegate {
-  return delegate_;
-}
-
-- (void)setDelegate:(id)delegate {
-  delegate_ = delegate;
-}
-
-@end
+#include "third_party/apple_cf/CFStreamAbstract.h"

[Mark Mentovai, 2015/03/11 20:47:42]

third_party < util

[Robert Sesek, 2015/03/11 20:53:57]

Done.

 
 namespace crashpad {
 
 namespace {
 
+// An implementation of CFReadStream. This implements the V0 callback
+// scheme.
+class HTTPBodyStreamCFReadStream {
+ public:
+  explicit HTTPBodyStreamCFReadStream(HTTPBodyStream* body_stream)
+      : body_stream_(body_stream) {
+  }
+
+  // Creates a new NSInputStream, which the caller owns.
+  NSInputStream* CreateInputStream() {
+    CFStreamClientContext context = {

[Mark Mentovai, 2015/03/11 20:47:42]

Can these both be const?

[Robert Sesek, 2015/03/11 20:53:56]

No, only the callbacks.

+      .version = 0,
+      .info = this,
+      .retain = nullptr,
+      .release = nullptr,
+      .copyDescription = nullptr
+    };
+    CFReadStreamCallBacksV0 callbacks = {
+      .version = 0,
+      .open = &Open,
+      .openCompleted = &OpenCompleted,
+      .read = &Read,
+      .getBuffer = &GetBuffer,
+      .canRead = &CanRead,
+      .close = &Close,
+      .copyProperty = &CopyProperty,
+      .schedule = &Schedule,
+      .unschedule = &Unschedule
+    };
+    CFReadStreamRef read_stream = CFReadStreamCreate(NULL,

[Mark Mentovai, 2015/03/11 20:47:42]

nullptr

[Robert Sesek, 2015/03/11 20:53:57]

Done. Force of habit with CF.

+        reinterpret_cast<const CFReadStreamCallBacks*>(&callbacks), &context);
+    return base::mac::CFToNSCast(read_stream);
+  }
+
+ private:
+  static HTTPBodyStream* GetStream(void* info) {
+    return static_cast<HTTPBodyStreamCFReadStream*>(info)->body_stream_;
+  }
+
+  static Boolean Open(CFReadStreamRef stream,
+                      CFStreamError* error,
+                      Boolean* open_complete,
+                      void* info) {
+    *open_complete = TRUE;
+    return TRUE;
+  }
+
+  static Boolean OpenCompleted(CFReadStreamRef stream,
+                               CFStreamError* error,
+                               void* info) {
+    return TRUE;
+  }
+
+  static CFIndex Read(CFReadStreamRef stream,
+                      UInt8* buffer,
+                      CFIndex buffer_length,
+                      CFStreamError* error,
+                      Boolean* at_eof,
+                      void* info) {
+    ssize_t bytes_read = GetStream(info)->GetBytesBuffer(buffer, buffer_length);

[Mark Mentovai, 2015/03/11 20:47:42]

Paranoia: if buffer_length == 0, just return 0.

[Robert Sesek, 2015/03/11 20:53:57]

Done.

+    if (bytes_read == 0) {
+      *at_eof = TRUE;
+    } else if (bytes_read < 0) {
+      error->error = -1;
+      error->domain = kCFStreamErrorDomainCustom;
+    }
+
+    return bytes_read;
+  }
+
+  static const UInt8* GetBuffer(CFReadStreamRef stream,
+                                CFIndex max_bytes_to_read,
+                                CFIndex* num_bytes_read,
+                                CFStreamError* error,
+                                Boolean* at_eof,
+                                void* info) {
+    return nullptr;
+  }
+
+  static Boolean CanRead(CFReadStreamRef stream, void* info) {
+    return TRUE;
+  }
+
+  static void Close(CFReadStreamRef stream, void* info) {}
+
+  static CFTypeRef CopyProperty(CFReadStreamRef stream,
+                                CFStringRef property_name,
+                                void* info) {
+    return nullptr;
+  }
+
+  static void Schedule(CFReadStreamRef stream,
+                       CFRunLoopRef run_loop,
+                       CFStringRef run_loop_mode,
+                       void* info) {}
+
+  static void Unschedule(CFReadStreamRef stream,
+                         CFRunLoopRef run_loop,
+                         CFStringRef run_loop_mode,
+                         void* info) {}
+
+  HTTPBodyStream* body_stream_;  // weak
+
+  DISALLOW_COPY_AND_ASSIGN(HTTPBodyStreamCFReadStream);
+};
+
 class HTTPTransportMac final : public HTTPTransport {
  public:
   HTTPTransportMac();
   ~HTTPTransportMac() override;
 
   bool ExecuteSynchronously(std::string* response_body) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(HTTPTransportMac);
 };
@@ skipping 14 matching lines @@
         [NSMutableURLRequest requestWithURL:url
                                 cachePolicy:NSURLRequestUseProtocolCachePolicy
                             timeoutInterval:timeout()];
     [request setHTTPMethod:base::SysUTF8ToNSString(method())];
 
     for (const auto& pair : headers()) {
       [request setValue:base::SysUTF8ToNSString(pair.second)
           forHTTPHeaderField:base::SysUTF8ToNSString(pair.first)];
     }
 
-    base::scoped_nsobject<CrashpadHTTPBodyStreamTransport> transport(
-        [[CrashpadHTTPBodyStreamTransport alloc] initWithBodyStream:
-            body_stream()]);
-    [request setHTTPBodyStream:transport.get()];
+    HTTPBodyStreamCFReadStream body_stream_cf(body_stream());
+    base::scoped_nsobject<NSInputStream> input_stream(
+        body_stream_cf.CreateInputStream());
+    [request setHTTPBodyStream:input_stream.get()];
 
     NSURLResponse* response = nil;
     NSError* error = nil;
     NSData* body = [NSURLConnection sendSynchronousRequest:request
                                          returningResponse:&response
                                                      error:&error];
 
     if (error) {
       LOG(ERROR) << [[error localizedDescription] UTF8String] << " ("
                  << [[error domain] UTF8String] << " " << [error code] << ")";
@@ skipping 26 matching lines @@
 }
 
 }  // namespace
 
 // static
 scoped_ptr<HTTPTransport> HTTPTransport::Create() {
   return scoped_ptr<HTTPTransport>(new HTTPTransportMac());
 }
 
 }  // namespace crashpad