Mac: Make ScopedTypeRef require explicit constructors

device/bluetooth/test/bluetooth_test_mac.mm

 // Copyright 2015 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 "device/bluetooth/test/bluetooth_test_mac.h"
 
 #include <stdint.h>
 
 #include "base/mac/foundation_util.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 23 matching lines @@
   MockCentralManager* get() { return mock_central_manager_.get(); };
 
  private:
   scoped_nsobject<MockCentralManager> mock_central_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedMockCentralManager);
 };
 
 namespace {
 
-NSDictionary* CreateAdvertisementData(NSString* name, NSArray* uuids) {
+scoped_nsobject<NSDictionary> CreateAdvertisementData(NSString* name,
+                                                      NSArray* uuids) {
   NSMutableDictionary* advertisement_data =
       [NSMutableDictionary dictionaryWithDictionary:@{
         CBAdvertisementDataLocalNameKey : name,
         CBAdvertisementDataServiceDataKey : @{},
         CBAdvertisementDataIsConnectable : @(YES),
       }];
   if (uuids) {
     [advertisement_data setObject:uuids
                            forKey:CBAdvertisementDataServiceUUIDsKey];
   }
-  return [advertisement_data retain];
+  return scoped_nsobject<NSDictionary>([advertisement_data retain]);

[Reilly Grant (use Gerrit), 2016/06/01 01:05:15]

I believe this retain was and still is unnecessary.

[ccameron, 2016/06/01 01:59:31]

Yeah, I suspected. Removed.

[Eugene But (OOO till 7-30), 2016/06/01 05:12:06]

Wait... this retain is still necessary (and actually was necessary).
1.) |dictionaryWithDictionary:| returns autoreleased objects 
2.) scoped_nsobject takes ownership over |advertisement_data|
3.) scoped_nsobject releases |advertisement_data| on destruction
4.) autorelease pool releases |advertisement_data| when it's drained

So dropping |retain| will lead to a crash, unless I'm missing something.

[Reilly Grant (use Gerrit), 2016/06/01 15:34:42]

I only pretend to understand Objective-C memory management. The documentation
doesn't *say* that it returns an autoreleased object but that makes sense.

[Eugene But (OOO till 7-30), 2016/06/01 15:58:35]

In Objective-C the method prefix tell if you are responsible for releasing the
object or not.
The following prefixes require callers to own the result:
- new
- alloc
- copy
- mutableCopy

https://developer.apple.com/library/mac/documentation/Cocoa/Conceptual/Memory...

[jlebel, 2016/06/02 23:07:34]

And "create" when we are using functions. That's the way it works for
CoreFoundation.

[ccameron, 2016/06/02 23:11:18]

I've added a base::scoped_policy::RETAIN here.

 }
 
 }  // namespace
 
 // UUID1 hashes to kTestDeviceAddress1, and UUID2 to kTestDeviceAddress2.
 const std::string BluetoothTestMac::kTestPeripheralUUID1 =
     "34045B00-0000-0000-0000-000000000000";
 const std::string BluetoothTestMac::kTestPeripheralUUID2 =
     "EC1B8F00-0000-0000-0000-000000000000";
 
@@ skipping 156 matching lines @@
                                     error:nil];
 }
 
 void BluetoothTestMac::SimulateGattServicesDiscovered(
     BluetoothDevice* device,
     const std::vector<std::string>& uuids) {
   BluetoothLowEnergyDeviceMac* device_mac =
       static_cast<BluetoothLowEnergyDeviceMac*>(device);
   CBPeripheral* peripheral = device_mac->GetPeripheral();
   MockCBPeripheral* peripheral_mock = ObjCCast<MockCBPeripheral>(peripheral);
-  scoped_nsobject<NSMutableArray> services = [[NSMutableArray alloc] init];
+  scoped_nsobject<NSMutableArray> services([[NSMutableArray alloc] init]);
   for (auto uuid : uuids) {
     CBUUID* cb_service_uuid = [CBUUID UUIDWithString:@(uuid.c_str())];
     [services addObject:cb_service_uuid];
   }
   [peripheral_mock removeAllServices];
   [peripheral_mock addServices:services];
   [peripheral_mock didDiscoverWithError:nil];
 }
 
 void BluetoothTestMac::SimulateGattServiceRemoved(
@@ skipping 52 matching lines @@
 //     crypto::SHA256HashString(input_str, raw, sizeof(raw));
 //     if (base::HexEncode(raw, sizeof(raw)) == target) {
 //       return input_str;
 //     }
 //     ++input[0];
 //   }
 //   return "";
 // }
 
 }  // namespace device