[ObjC ARC] Converts ios/chrome/common:unit_tests to ARC.

ios/chrome/common/block_unittest.mm

 // Copyright (c) 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 <Foundation/Foundation.h>
 #include <vector>
 
 #include "base/memory/ref_counted.h"
 #include "testing/platform_test.h"
 
 // This test verifies assumptions about the murky world of interaction between
 // C++ objects and blocks. Just to make sure.
+// This class should not use ARC. When everything is ARC, it can be removed.

[sdefresne, 2017/02/13 14:15:57]

This is my first time looking at this file (since it was not in the previous
CL).

I think your comment is incorrect and we want to keep this test once we have
migrated everything with ARC. And we also want to migrate this test. It is an
important test checking that ref-counted C++ object are correctly copied when
captured by blocks.

To convert his file to ARC, we need to have deterministic way to release the
blocks. I think this is possible by using @autoreleasepool, applying the
following transformation from:

  void (^heap_block)(int) = nil;
  {
    heap_block = [^(int) {} copy];
  }
  heap_block(2);
  [heap_block release];
  EXPECT_TRUE(object->HasOneRef());

to the following:

  @autoreleasepool {
    void (^heap_block)(int) = nil;
    {
      heap_block = [^(int) {} copy];
    }
    heap_block(2);
  }
  EXPECT_TRUE(object->HasOneRef());

[sdefresne, 2017/02/14 10:04:24]

As discussed on hangouts, remove this comment and I'll take care of converting
the test to ARC (https://codereview.chromium.org/2697613003/).

 
 namespace {
 
 class RefCountedObject : public base::RefCounted<RefCountedObject> {
  public:
   RefCountedObject() {}
 
   // Refcount is private in the superclass, fake it by counting how many times
   // release can be called until there is one count left, then retain the count
   // back.
@@ skipping 68 matching lines @@
     vector.push_back(22);
     stack_block();
     heap_block = [stack_block copy];
     stack_block();
   }
   heap_block();
   [heap_block release];
 }
 
 }  // namespace