Update OS X to use scoped_refptr<T>::get() rather than implicit "operator T*"

content/browser/loader/upload_data_stream_builder_unittest.cc

 // Copyright 2013 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 "content/browser/loader/upload_data_stream_builder.h"
 
 #include <algorithm>
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
@@ skipping 53 matching lines @@
   const uint64 kFileOffset = 10U;
   const uint64 kFileLength = 100U;
   const base::Time kFileTime = base::Time::FromDoubleT(999);
   const int64 kIdentifier = 12345;
 
   request_body->AppendBytes(kData, arraysize(kData) - 1);
   request_body->AppendFileRange(base::FilePath(kFilePath),
                                 kFileOffset, kFileLength, kFileTime);
   request_body->set_identifier(kIdentifier);
 
-  scoped_ptr<net::UploadDataStream> upload(
-      UploadDataStreamBuilder::Build(
-          request_body, NULL, NULL, base::MessageLoopProxy::current().get()));
+  scoped_ptr<net::UploadDataStream> upload(UploadDataStreamBuilder::Build(
+      request_body.get(), NULL, NULL, base::MessageLoopProxy::current().get()));
 
   EXPECT_EQ(kIdentifier, upload->identifier());
   ASSERT_EQ(request_body->elements()->size(), upload->element_readers().size());
 
   const net::UploadBytesElementReader* r1 =
       upload->element_readers()[0]->AsBytesReader();
   ASSERT_TRUE(r1);
   EXPECT_EQ(kData, std::string(r1->bytes(), r1->length()));
 
   const net::UploadFileElementReader* r2 =
@@ skipping 50 matching lines @@
 
   // Test no blob reference.
   scoped_refptr<ResourceRequestBody> request_body(new ResourceRequestBody());
   request_body->AppendBytes(upload_element1.bytes(), upload_element1.length());
   request_body->AppendFileRange(upload_element2.path(),
                                 upload_element2.offset(),
                                 upload_element2.length(),
                                 upload_element2.expected_modification_time());
 
   scoped_ptr<net::UploadDataStream> upload(
-      UploadDataStreamBuilder::Build(
-          request_body,
-          &blob_storage_controller,
-          NULL,
-          base::MessageLoopProxy::current().get()));
+      UploadDataStreamBuilder::Build(request_body.get(),
+                                     &blob_storage_controller,
+                                     NULL,
+                                     base::MessageLoopProxy::current().get()));
 
   ASSERT_EQ(2U, upload->element_readers().size());
   EXPECT_TRUE(AreElementsEqual(*upload->element_readers()[0], upload_element1));
   EXPECT_TRUE(AreElementsEqual(*upload->element_readers()[1], upload_element2));
 
   // Test having only one blob reference that refers to empty blob data.
   request_body = new ResourceRequestBody();
   request_body->AppendBlob(blob_url0);
 
-  upload = UploadDataStreamBuilder::Build(
-      request_body,
-      &blob_storage_controller,
-      NULL,
-      base::MessageLoopProxy::current().get());
+  upload =
+      UploadDataStreamBuilder::Build(request_body.get(),
+                                     &blob_storage_controller,
+                                     NULL,
+                                     base::MessageLoopProxy::current().get());
   ASSERT_EQ(0U, upload->element_readers().size());
 
   // Test having only one blob reference.
   request_body = new ResourceRequestBody();
   request_body->AppendBlob(blob_url1);
 
-  upload = UploadDataStreamBuilder::Build(
-      request_body,
-      &blob_storage_controller,
-      NULL,
-      base::MessageLoopProxy::current().get());
+  upload =
+      UploadDataStreamBuilder::Build(request_body.get(),
+                                     &blob_storage_controller,
+                                     NULL,
+                                     base::MessageLoopProxy::current().get());
   ASSERT_EQ(2U, upload->element_readers().size());
   EXPECT_TRUE(AreElementsEqual(*upload->element_readers()[0], blob_element1));
   EXPECT_TRUE(AreElementsEqual(*upload->element_readers()[1], blob_element2));
 
   // Test having one blob reference at the beginning.
   request_body = new ResourceRequestBody();
   request_body->AppendBlob(blob_url1);
   request_body->AppendBytes(upload_element1.bytes(), upload_element1.length());
   request_body->AppendFileRange(upload_element2.path(),
                                 upload_element2.offset(),
                                 upload_element2.length(),
                                 upload_element2.expected_modification_time());
 
-  upload = UploadDataStreamBuilder::Build(
-      request_body,
-      &blob_storage_controller,
-      NULL,
-      base::MessageLoopProxy::current().get());
+  upload =
+      UploadDataStreamBuilder::Build(request_body.get(),
+                                     &blob_storage_controller,
+                                     NULL,
+                                     base::MessageLoopProxy::current().get());
   ASSERT_EQ(4U, upload->element_readers().size());
   EXPECT_TRUE(AreElementsEqual(*upload->element_readers()[0], blob_element1));
   EXPECT_TRUE(AreElementsEqual(*upload->element_readers()[1], blob_element2));
   EXPECT_TRUE(AreElementsEqual(*upload->element_readers()[2], upload_element1));
   EXPECT_TRUE(AreElementsEqual(*upload->element_readers()[3], upload_element2));
 
   // Test having one blob reference at the end.
   request_body = new ResourceRequestBody();
   request_body->AppendBytes(upload_element1.bytes(), upload_element1.length());
   request_body->AppendFileRange(upload_element2.path(),
                                 upload_element2.offset(),
                                 upload_element2.length(),
                                 upload_element2.expected_modification_time());
   request_body->AppendBlob(blob_url1);
 
-  upload = UploadDataStreamBuilder::Build(
-      request_body,
-      &blob_storage_controller,
-      NULL,
-      base::MessageLoopProxy::current().get());
+  upload =
+      UploadDataStreamBuilder::Build(request_body.get(),
+                                     &blob_storage_controller,
+                                     NULL,
+                                     base::MessageLoopProxy::current().get());
   ASSERT_EQ(4U, upload->element_readers().size());
   EXPECT_TRUE(AreElementsEqual(*upload->element_readers()[0], upload_element1));
   EXPECT_TRUE(AreElementsEqual(*upload->element_readers()[1], upload_element2));
   EXPECT_TRUE(AreElementsEqual(*upload->element_readers()[2], blob_element1));
   EXPECT_TRUE(AreElementsEqual(*upload->element_readers()[3], blob_element2));
 
   // Test having one blob reference in the middle.
   request_body = new ResourceRequestBody();
   request_body->AppendBytes(upload_element1.bytes(), upload_element1.length());
   request_body->AppendBlob(blob_url1);
   request_body->AppendFileRange(upload_element2.path(),
                                 upload_element2.offset(),
                                 upload_element2.length(),
                                 upload_element2.expected_modification_time());
 
-  upload = UploadDataStreamBuilder::Build(
-      request_body,
-      &blob_storage_controller,
-      NULL,
-      base::MessageLoopProxy::current().get());
+  upload =
+      UploadDataStreamBuilder::Build(request_body.get(),
+                                     &blob_storage_controller,
+                                     NULL,
+                                     base::MessageLoopProxy::current().get());
   ASSERT_EQ(4U, upload->element_readers().size());
   EXPECT_TRUE(AreElementsEqual(*upload->element_readers()[0], upload_element1));
   EXPECT_TRUE(AreElementsEqual(*upload->element_readers()[1], blob_element1));
   EXPECT_TRUE(AreElementsEqual(*upload->element_readers()[2], blob_element2));
   EXPECT_TRUE(AreElementsEqual(*upload->element_readers()[3], upload_element2));
 
   // Test having multiple blob references.
   request_body = new ResourceRequestBody();
   request_body->AppendBlob(blob_url1);
   request_body->AppendBytes(upload_element1.bytes(), upload_element1.length());
   request_body->AppendBlob(blob_url2);
   request_body->AppendBlob(blob_url3);
   request_body->AppendFileRange(upload_element2.path(),
                                 upload_element2.offset(),
                                 upload_element2.length(),
                                 upload_element2.expected_modification_time());
 
-  upload = UploadDataStreamBuilder::Build(
-      request_body,
-      &blob_storage_controller,
-      NULL,
-      base::MessageLoopProxy::current().get());
+  upload =
+      UploadDataStreamBuilder::Build(request_body.get(),
+                                     &blob_storage_controller,
+                                     NULL,
+                                     base::MessageLoopProxy::current().get());
   ASSERT_EQ(8U, upload->element_readers().size());
   EXPECT_TRUE(AreElementsEqual(*upload->element_readers()[0], blob_element1));
   EXPECT_TRUE(AreElementsEqual(*upload->element_readers()[1], blob_element2));
   EXPECT_TRUE(AreElementsEqual(*upload->element_readers()[2], upload_element1));
   EXPECT_TRUE(AreElementsEqual(*upload->element_readers()[3], blob_element1));
   EXPECT_TRUE(AreElementsEqual(*upload->element_readers()[4], blob_element2));
   EXPECT_TRUE(AreElementsEqual(*upload->element_readers()[5], blob_element1));
   EXPECT_TRUE(AreElementsEqual(*upload->element_readers()[6], blob_element2));
   EXPECT_TRUE(AreElementsEqual(*upload->element_readers()[7], upload_element2));
 }
 
 }  // namespace content