Remove ScopedVector from ElementsUploadDataStream

ios/net/crn_http_protocol_handler.mm

 // Copyright 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.
 
 #import "ios/net/crn_http_protocol_handler.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/mac/bind_objc_block.h"
 #include "base/mac/scoped_nsobject.h"
@@ skipping 175 matching lines @@
   // NSURLProtocol client, and the following clients are ordered such as the
   // ith client is responsible for managing the (i-1)th client.
   base::scoped_nsobject<NSMutableArray> clients_;
   // Weak. This is the last client in |clients_|.
   id<CRNNetworkClientProtocol> top_level_client_;
   scoped_refptr<IOBuffer> buffer_;
   base::scoped_nsobject<NSMutableURLRequest> request_;
   // Stream delegate to read the HTTPBodyStream.
   base::scoped_nsobject<CRWHTTPStreamDelegate> stream_delegate_;
   // Vector of readers used to accumulate a POST data stream.
-  ScopedVector<UploadElementReader> post_data_readers_;
+  std::vector<scoped_ptr<UploadElementReader>> post_data_readers_;

[mmenke, 2015/11/24 17:25:08]

include <vector>, scoped_ptr

 
   // This cannot be a scoped pointer because it must be deleted on the IO
   // thread.
   URLRequest* net_request_;
 
   base::WeakPtr<RequestTracker> tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpProtocolHandlerCore);
 };
 
@@ skipping 24 matching lines @@
           << base::SysNSStringToUTF8([[stream streamError] description]);
       StopListeningStream(stream);
       StopRequestWithError(NSURLErrorUnknown, ERR_UNEXPECTED);
       break;
     case NSStreamEventEndEncountered:
       StopListeningStream(stream);
       if (!post_data_readers_.empty()) {
         // NOTE: This call will result in |post_data_readers_| being cleared,
         // which is the desired behavior.
         net_request_->set_upload(make_scoped_ptr(
-            new ElementsUploadDataStream(post_data_readers_.Pass(), 0)));
+            new ElementsUploadDataStream(std::move(post_data_readers_), 0)));
         DCHECK(post_data_readers_.empty());
       }
       net_request_->Start();
       if (tracker_)
         tracker_->StartRequest(net_request_);
       break;
     case NSStreamEventHasBytesAvailable: {
       NSUInteger length;
       DCHECK([stream isKindOfClass:[NSInputStream class]]);
       length = [(NSInputStream*)stream read:(unsigned char*)buffer_->data()
                                   maxLength:kIOBufferSize];
       if (length) {
         std::vector<char> owned_data(buffer_->data(), buffer_->data() + length);
         post_data_readers_.push_back(
-            new UploadOwnedBytesElementReader(&owned_data));
+            make_scoped_ptr(new UploadOwnedBytesElementReader(&owned_data)));
       }
       break;
     }
     case NSStreamEventNone:
     case NSStreamEventOpenCompleted:
     case NSStreamEventHasSpaceAvailable:
       break;
     default:
       NOTREACHED() << "Unexpected stream event: " << event;
       break;
@@ skipping 822 matching lines @@
       [[DeferredCancellation alloc] initWithCore:[self getCore]];
   NSArray* modes = @[ [[NSRunLoop currentRunLoop] currentMode] ];
   [cancellation performSelector:@selector(cancel)
                        onThread:[self getClientThread]
                      withObject:nil
                   waitUntilDone:NO
                           modes:modes];
 }
 
 @end