Clean up bookmark_editor_controller to so that is closes consistently as both...

chrome/browser/cocoa/bookmark_editor_controller_unittest.mm

 // Copyright (c) 2009 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 <Cocoa/Cocoa.h>
 
 #include "base/scoped_nsobject.h"
 #include "base/sys_string_conversions.h"
 #import "chrome/browser/cocoa/bookmark_editor_controller.h"
 #include "chrome/browser/cocoa/browser_test_helper.h"
 #import "chrome/browser/cocoa/cocoa_test_helper.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
-class BookmarkEditorControllerTest : public PlatformTest {
+class BookmarkEditorControllerTest : public CocoaTest {
  public:
-  CocoaTestHelper cocoa_helper_;  // Inits Cocoa, creates window, etc...
   BrowserTestHelper helper_;
   const BookmarkNode* default_node_;
   const BookmarkNode* default_parent_;
   const char* default_name_;
   std::wstring default_title_;
-  scoped_nsobject<BookmarkEditorController> default_controller_;
+  BookmarkEditorController* default_controller_;
 
-  BookmarkEditorControllerTest() {
+  virtual void SetUp() {
+    CocoaTest::SetUp();
     BookmarkModel* model = helper_.profile()->GetBookmarkModel();
     default_parent_ = model->GetBookmarkBarNode();
     default_name_ = "http://www.zim-bop-a-dee.com/";
     default_title_ = L"ooh title";
     const BookmarkNode* default_node = model->AddURL(default_parent_, 0,
                                                      default_title_,
                                                      GURL(default_name_));
-    default_controller_.reset([[BookmarkEditorController alloc]
-                                initWithParentWindow:cocoa_helper_.window()
-                                             profile:helper_.profile()
-                                              parent:default_parent_
-                                                node:default_node
-                                       configuration:BookmarkEditor::NO_TREE
-                                             handler:nil]);
+    default_controller_ = [[BookmarkEditorController alloc]
+                              initWithParentWindow:test_window()
+                                           profile:helper_.profile()
+                                            parent:default_parent_
+                                              node:default_node
+                                     configuration:BookmarkEditor::NO_TREE
+                                           handler:nil];
     [default_controller_ window];  // Forces a nib load
   }
+
+  virtual void TearDown() {
+    [default_controller_ close];
+    CocoaTest::TearDown();
+  }
 };
 
 TEST_F(BookmarkEditorControllerTest, NoNodeNoTree) {
   BookmarkModel* model = helper_.profile()->GetBookmarkModel();
   const BookmarkNode* parent = model->GetBookmarkBarNode();
   const BookmarkNode* node = NULL;
 
-  scoped_nsobject<BookmarkEditorController>
-    controller([[BookmarkEditorController alloc]
-                 initWithParentWindow:cocoa_helper_.window()
-                              profile:helper_.profile()
-                               parent:parent
-                                 node:node
-                        configuration:BookmarkEditor::NO_TREE
-                              handler:nil]);
+  BookmarkEditorController* controller =
+      [[BookmarkEditorController alloc]
+          initWithParentWindow:test_window()
+                       profile:helper_.profile()
+                        parent:parent
+                          node:node
+                 configuration:BookmarkEditor::NO_TREE
+                       handler:nil];
 
   EXPECT_NE((NSWindow*)nil, [controller window]);  // Forces a nib load
   EXPECT_EQ(@"", [controller displayName]);
   EXPECT_EQ(@"", [controller displayURL]);
   EXPECT_FALSE([controller okButtonEnabled]);
+  [controller close];
 }
 
 TEST_F(BookmarkEditorControllerTest, YesNodeShowTree) {
   BookmarkModel* model = helper_.profile()->GetBookmarkModel();
   const BookmarkNode* parent = model->GetBookmarkBarNode();
   const char* url_name = "http://www.zim-bop-a-dee.com/";
   const BookmarkNode* node = model->AddURL(parent, 0, default_title_,
                                            GURL(url_name));
 
-  scoped_nsobject<BookmarkEditorController>
-    controller([[BookmarkEditorController alloc]
-                 initWithParentWindow:cocoa_helper_.window()
-                              profile:helper_.profile()
-                               parent:parent
-                                 node:node
-                        configuration:BookmarkEditor::SHOW_TREE
-                              handler:nil]);
+  BookmarkEditorController* controller =
+    [[BookmarkEditorController alloc]
+        initWithParentWindow:test_window()
+                     profile:helper_.profile()
+                      parent:parent
+                        node:node
+               configuration:BookmarkEditor::SHOW_TREE
+                     handler:nil];
 
   EXPECT_NE((NSWindow*)nil, [controller window]);  // Forces a nib load
   EXPECT_TRUE([base::SysWideToNSString(default_title_)
                 isEqual:[controller displayName]]);
   EXPECT_TRUE([[NSString stringWithCString:url_name
                                   encoding:NSUTF8StringEncoding]
                 isEqual:[controller displayURL]]);
+  [controller close];
 }
 
 TEST_F(BookmarkEditorControllerTest, NoEdit) {
   [default_controller_ ok:nil];
   ASSERT_EQ(default_parent_->GetChildCount(), 1);
   const BookmarkNode* child = default_parent_->GetChild(0);
   EXPECT_EQ(child->GetTitle(), default_title_);
   EXPECT_EQ(child->GetURL(), GURL(default_name_));
 }
 
@@ skipping 38 matching lines @@
   EXPECT_FALSE([default_controller_ okButtonEnabled]);
   [default_controller_ setDisplayName:@"                   "];
   EXPECT_TRUE([default_controller_ okButtonEnabled]);
   // Then little mix of both.
   [default_controller_ setDisplayName:@"name"];
   EXPECT_TRUE([default_controller_ okButtonEnabled]);
   [default_controller_ setDisplayURL:@""];
   EXPECT_FALSE([default_controller_ okButtonEnabled]);
 }
 
-class BookmarkEditorControllerTreeTest : public PlatformTest {
+class BookmarkEditorControllerTreeTest : public CocoaTest {
  public:
-  CocoaTestHelper cocoa_helper_;  // Inits Cocoa, creates window, etc...
   BrowserTestHelper helper_;
-  scoped_nsobject<BookmarkEditorController> default_controller_;
+  BookmarkEditorController* default_controller_;
   const BookmarkNode* group_a_;
   const BookmarkNode* group_b_;
   const BookmarkNode* group_bb_;
   const BookmarkNode* group_c_;
   const BookmarkNode* bookmark_bb_3_;
 
   BookmarkEditorControllerTreeTest() {
     // Set up a small bookmark hierarchy, which will look as follows:
     //    a      b      c    d
     //     a-0    b-0    c-0
@@ skipping 23 matching lines @@
     model.AddURL(group_b_, 2, L"b-2", GURL("http://b-2.com"));
     model.AddURL(group_b_, 3, L"b-2", GURL("http://b-3.com"));
 
     group_c_ = model.AddGroup(root, 2, L"c");
     model.AddURL(group_c_, 0, L"c-0", GURL("http://c-0.com"));
     model.AddURL(group_c_, 1, L"c-1", GURL("http://c-1.com"));
     model.AddURL(group_c_, 2, L"c-2", GURL("http://c-2.com"));
     model.AddURL(group_c_, 3, L"c-3", GURL("http://c-3.com"));
 
     model.AddURL(root, 3, L"d", GURL("http://d-0.com"));
+  }
 
-    default_controller_.reset([[BookmarkEditorController alloc]
-                               initWithParentWindow:cocoa_helper_.window()
-                               profile:helper_.profile()
-                               parent:group_bb_
+  virtual BookmarkEditorController* CreateController() {
+    return [[BookmarkEditorController alloc]
+               initWithParentWindow:test_window()
+                            profile:helper_.profile()
+                             parent:group_bb_
                                node:bookmark_bb_3_
-                               configuration:BookmarkEditor::SHOW_TREE
-                               handler:nil]);
-    [default_controller_ window];  // Forces a nib load
+                      configuration:BookmarkEditor::SHOW_TREE
+                            handler:nil];
+  }
+
+  virtual void SetUp() {
+    CocoaTest::SetUp();
+    default_controller_ = CreateController();
+    EXPECT_TRUE([default_controller_ window]);
+  }
+
+  virtual void TearDown() {
+    [default_controller_ close];
+    CocoaTest::TearDown();
   }
 };
 
 TEST_F(BookmarkEditorControllerTreeTest, VerifyBookmarkTestModel) {
   BookmarkModel& model(*(helper_.profile()->GetBookmarkModel()));
+  model.root_node();
   const BookmarkNode& root(*model.GetBookmarkBarNode());
   EXPECT_EQ(4, root.GetChildCount());
   const BookmarkNode* child = root.GetChild(0);
   EXPECT_EQ(3, child->GetChildCount());
   const BookmarkNode* subchild = child->GetChild(0);
   EXPECT_EQ(0, subchild->GetChildCount());
   subchild = child->GetChild(1);
   EXPECT_EQ(0, subchild->GetChildCount());
   subchild = child->GetChild(2);
   EXPECT_EQ(0, subchild->GetChildCount());
@@ skipping 78 matching lines @@
   [default_controller_ newFolder:nil];
   [default_controller_ cancel:nil];
   EXPECT_EQ(6, group_bb_->GetChildCount());
   const BookmarkNode* folderChild = group_bb_->GetChild(5);
   EXPECT_EQ(folderChild->GetTitle(), L"New folder");
 }
 
 class BookmarkEditorControllerTreeNoNodeTest :
     public BookmarkEditorControllerTreeTest {
  public:
-  BookmarkEditorControllerTreeNoNodeTest() {
-    // Reset the controller so that we have no |node|.
-    default_controller_.reset([[BookmarkEditorController alloc]
-                               initWithParentWindow:cocoa_helper_.window()
-                               profile:helper_.profile()
-                               parent:group_bb_
+  virtual BookmarkEditorController* CreateController() {
+    return [[BookmarkEditorController alloc]
+               initWithParentWindow:test_window()
+                            profile:helper_.profile()
+                             parent:group_bb_
                                node:nil
-                               configuration:BookmarkEditor::SHOW_TREE
-                               handler:nil]);
-    [default_controller_ window];  // Forces a nib load
+                      configuration:BookmarkEditor::SHOW_TREE
+                            handler:nil];
   }
+
 };
 
 TEST_F(BookmarkEditorControllerTreeNoNodeTest, NewBookmarkNoNode) {
   [default_controller_ setDisplayName:@"NEW BOOKMARK"];
   [default_controller_ setDisplayURL:@"http://NEWURL.com"];
   [default_controller_ ok:nil];
   const BookmarkNode* new_node = group_bb_->GetChild(5);
   ASSERT_EQ(0, new_node->GetChildCount());
   EXPECT_EQ(new_node->GetTitle(), L"NEW BOOKMARK");
   EXPECT_EQ(new_node->GetURL(), GURL("http://NEWURL.com"));
 }
 
 class BookmarkEditorControllerTreeNoParentTest :
     public BookmarkEditorControllerTreeTest {
  public:
-  BookmarkEditorControllerTreeNoParentTest() {
-    // Reset the controller so that we have no |node|.
-    default_controller_.reset([[BookmarkEditorController alloc]
-                               initWithParentWindow:cocoa_helper_.window()
-                               profile:helper_.profile()
-                               parent:nil
-                               node:nil
-                               configuration:BookmarkEditor::SHOW_TREE
-                               handler:nil]);
-    [default_controller_ window];  // Forces a nib load
-  }
+  virtual BookmarkEditorController* CreateController() {
+    return [[BookmarkEditorController alloc]
+               initWithParentWindow:test_window()
+                            profile:helper_.profile()
+                            parent:nil
+                              node:nil
+                     configuration:BookmarkEditor::SHOW_TREE
+                           handler:nil];
+      }
 };
 
 TEST_F(BookmarkEditorControllerTreeNoParentTest, AddFolderWithNoGroupSelected) {
   [default_controller_ newFolder:nil];
   [default_controller_ cancel:nil];
   BookmarkModel* model = helper_.profile()->GetBookmarkModel();
   const BookmarkNode* bookmarkBar = model->GetBookmarkBarNode();
   EXPECT_EQ(5, bookmarkBar->GetChildCount());
   const BookmarkNode* folderChild = bookmarkBar->GetChild(4);
   EXPECT_EQ(folderChild->GetTitle(), L"New folder");
 }