Un-refcount AutofillWebData and TokenWebData

chrome/browser/sync/profile_sync_service_autofill_unittest.cc

 // 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.
 
 #include <set>
 #include <string>
 #include <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 208 matching lines @@
 class WebDataServiceFake : public AutofillWebDataService {
  public:
   WebDataServiceFake()
       : AutofillWebDataService(),
         web_database_(NULL),
         autocomplete_syncable_service_(NULL),
         autofill_profile_syncable_service_(NULL),
         syncable_service_created_or_destroyed_(false, false) {
   }
 
+  virtual ~WebDataServiceFake() {}
+
   void SetDatabase(WebDatabase* web_database) {
     web_database_ = web_database;
   }
 
   void StartSyncableService() {
     // The |autofill_profile_syncable_service_| must be constructed on the DB
     // thread.
     const base::Closure& on_changed_callback = base::Bind(
         &WebDataServiceFake::NotifyAutofillMultipleChangedOnUIThread,
         AsWeakPtr());
@@ skipping 44 matching lines @@
                    base::Unretained(autofill_profile_syncable_service_),
                    changes);
     BrowserThread::PostTask(
         BrowserThread::DB,
         FROM_HERE,
         base::Bind(&RunAndSignal, notify_cb, &event));
     event.Wait();
   }
 
  private:
-  virtual ~WebDataServiceFake() {}
-
   void CreateSyncableService(const base::Closure& on_changed_callback) {
     ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::DB));
     // These services are deleted in DestroySyncableService().
     backend_.reset(new MockAutofillBackend(
         GetDatabase(), on_changed_callback));
     AutocompleteSyncableService::CreateForWebDataServiceAndBackend(
         this, backend_.get());
     AutofillProfileSyncableService::CreateForWebDataServiceAndBackend(
         this, backend_.get(), "en-US");
 
@@ skipping 199 matching lines @@
   virtual void SetUp() OVERRIDE {
     AbstractProfileSyncServiceTest::SetUp();
     profile_.reset(new ProfileMock());
     profile_->CreateRequestContext();
     web_database_.reset(new WebDatabaseFake(&autofill_table_));
     MockWebDataServiceWrapper* wrapper =
         static_cast<MockWebDataServiceWrapper*>(
             WebDataServiceFactory::GetInstance()->SetTestingFactoryAndUse(
                 profile_.get(), BuildMockWebDataServiceWrapper));
     web_data_service_ =
-        static_cast<WebDataServiceFake*>(wrapper->GetAutofillWebData().get());
+        static_cast<WebDataServiceFake*>(wrapper->GetAutofillWebData());
     web_data_service_->SetDatabase(web_database_.get());
 
     MockPersonalDataManagerService* personal_data_manager_service =
         static_cast<MockPersonalDataManagerService*>(
             autofill::PersonalDataManagerFactory::GetInstance()
                 ->SetTestingFactoryAndUse(
                     profile_.get(), MockPersonalDataManagerService::Build));
     personal_data_manager_ =
         personal_data_manager_service->GetPersonalDataManager();
 
@@ skipping 45 matching lines @@
     sync_service_->set_backend_init_callback(callback);
 
     ProfileSyncComponentsFactoryMock* components =
         sync_service_->components_factory_mock();
     DataTypeController* data_type_controller =
         factory->CreateDataTypeController(components,
                                           profile_.get(),
                                           sync_service_);
     factory->SetExpectation(components,
                             sync_service_,
-                            web_data_service_.get(),
+                            web_data_service_,
                             data_type_controller);
 
     EXPECT_CALL(*components, CreateDataTypeManager(_, _, _, _, _, _)).
         WillOnce(ReturnNewDataTypeManagerWithDebugListener(
                      syncer::MakeWeakHandle(debug_ptr_factory_.GetWeakPtr())));
 
     EXPECT_CALL(*personal_data_manager_, IsDataLoaded()).
         WillRepeatedly(Return(true));
 
      // We need tokens to get the tests going
@@ skipping 159 matching lines @@
     return MakeAutofillEntry(name, value, time_shift, -1);
   }
 
   friend class AddAutofillHelper<AutofillEntry>;
   friend class AddAutofillHelper<AutofillProfile>;
   friend class FakeServerUpdater;
 
   scoped_ptr<ProfileMock> profile_;
   AutofillTableMock autofill_table_;
   scoped_ptr<WebDatabaseFake> web_database_;
-  scoped_refptr<WebDataServiceFake> web_data_service_;
+  WebDataServiceFake* web_data_service_;
   MockPersonalDataManager* personal_data_manager_;
   syncer::DataTypeAssociationStats association_stats_;
   base::WeakPtrFactory<DataTypeDebugInfoListener> debug_ptr_factory_;
 };
 
 template <class T>
 class AddAutofillHelper {
  public:
   AddAutofillHelper(ProfileSyncServiceAutofillTest* test,
                     const std::vector<T>& entries)
@@ skipping 157 matching lines @@
 
   std::set<string16> values_set;
   for (size_t i = 0; i < values1.size(); ++i)
     values_set.insert(values1[i]);
   for (size_t i = 0; i < values2.size(); ++i)
     if (values_set.find(values2[i]) == values_set.end())
       return false;
   return true;
 }
 
-};
+};  // namespace
 
 // TODO(skrul): Test abort startup.
 // TODO(skrul): Test processing of cloud changes.
 // TODO(tim): Add autofill data type controller test, and a case to cover
 //            waiting for the PersonalDataManager.
 TEST_F(ProfileSyncServiceAutofillTest, FailModelAssociation) {
   // Don't create the root autofill node so startup fails.
   StartSyncService(base::Closure(), true, syncer::AUTOFILL);
   EXPECT_TRUE(sync_service_->HasUnrecoverableError());
 }
@@ skipping 453 matching lines @@
   std::vector<AutofillEntry> sync_entries;
   std::vector<AutofillProfile> sync_profiles;
   ASSERT_TRUE(GetAutofillEntriesFromSyncDB(&sync_entries, &sync_profiles));
   EXPECT_EQ(3U, sync_entries.size());
   EXPECT_EQ(0U, sync_profiles.size());
   for (size_t i = 0; i < sync_entries.size(); i++) {
     DVLOG(1) << "Entry " << i << ": " << sync_entries[i].key().name()
              << ", " << sync_entries[i].key().value();
   }
 }