sqlite_utils: don't dereference an empty vector.

chrome/browser/sync/util/user_settings_unittest.cc

 // Copyright (c) 2010 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 <limits>
 #include <string>
 
 #include "base/file_util.h"
 #include "base/scoped_temp_dir.h"
 #include "chrome/browser/sync/syncable/directory_manager.h"
@@ skipping 22 matching lines @@
   UserSettingsTest() : sync_data_("Some sync data") { }
 
   // Creates and populates the V10 database files within
   // |destination_directory|.
   void SetUpVersion10Databases(const FilePath& destination_directory) {
     sqlite3* primer_handle = NULL;
     v10_user_setting_db_path_ =
         destination_directory.Append(FilePath(kV10UserSettingsDB));
     ASSERT_EQ(SQLITE_OK, sqlite_utils::OpenSqliteDb(v10_user_setting_db_path_,
                                                     &primer_handle));
+    sqlite_utils::scoped_sqlite_db_ptr db(primer_handle);
+
     old_style_sync_data_path_ =
         destination_directory.Append(FilePath(kOldStyleSyncDataDB));
 
     ASSERT_EQ(sync_data_.length(),
               static_cast<size_t>(file_util::WriteFile(
                   old_style_sync_data_path_, sync_data_.data(),
                   sync_data_.length())));
 
     // Create settings table.
     ExecOrDie(primer_handle, "CREATE TABLE settings"
@@ skipping 22 matching lines @@
       SQLStatement statement;
       const char query[] = "INSERT INTO shares values ( ?, ?, ? )";
       statement.prepare(primer_handle, query);
       statement.bind_string(0, "foo@foo.com");
       statement.bind_string(1, "foo@foo.com");
       statement.bind_string(2, FilePathToUTF8(old_style_sync_data_path_));
       if (SQLITE_DONE != statement.step()) {
         LOG(FATAL) << query << "\n" << sqlite3_errmsg(primer_handle);
       }
     }
-    sqlite3_close(primer_handle);
   }
 
    // Creates and populates the V11 database file within
   // |destination_directory|.
   void SetUpVersion11Database(const FilePath& destination_directory) {
     sqlite3* primer_handle = NULL;
     v11_user_setting_db_path_ =
         destination_directory.Append(FilePath(kV11UserSettingsDB));
     ASSERT_EQ(SQLITE_OK, sqlite_utils::OpenSqliteDb(v11_user_setting_db_path_,
                                                     &primer_handle));
+    sqlite_utils::scoped_sqlite_db_ptr db(primer_handle);
 
     // Create settings table.
     ExecOrDie(primer_handle, "CREATE TABLE settings"
               " (email, key, value, "
               "  PRIMARY KEY(email, key) ON CONFLICT REPLACE)");
 
     // Create and populate version table.
     ExecOrDie(primer_handle, "CREATE TABLE db_version ( version )");
     {
       SQLStatement statement;
@@ skipping 11 matching lines @@
     {
       SQLStatement statement;
       const char query[] = "INSERT INTO signin_types values ( ?, ? )";
       statement.prepare(primer_handle, query);
       statement.bind_string(0, "test");
       statement.bind_string(1, "test");
       if (SQLITE_DONE != statement.step()) {
         LOG(FATAL) << query << "\n" << sqlite3_errmsg(primer_handle);
       }
     }
-
-    sqlite3_close(primer_handle);
   }
 
   const std::string& sync_data() const { return sync_data_; }
   const FilePath& v10_user_setting_db_path() const {
     return v10_user_setting_db_path_;
   }
   const FilePath& v11_user_setting_db_path() const {
     return v11_user_setting_db_path_;
   }
   const FilePath& old_style_sync_data_path() const {
@@ skipping 18 matching lines @@
     // inside a scoped block so it closes itself and we can poke around to see
     // what happened later.
     UserSettings settings;
     settings.Init(v10_user_setting_db_path());
   }
 
   // Now poke around using sqlite to see if UserSettings migrated properly.
   sqlite3* handle = NULL;
   ASSERT_EQ(SQLITE_OK, sqlite_utils::OpenSqliteDb(v10_user_setting_db_path(),
                                                   &handle));
+  sqlite_utils::scoped_sqlite_db_ptr db(handle);
 
   // Note that we don't use ScopedStatement to avoid closing the sqlite handle
   // before finalizing the statement.
   {
     SQLStatement version_query;
     version_query.prepare(handle, "SELECT version FROM db_version");
     ASSERT_EQ(SQLITE_ROW, version_query.step());
     const int version = version_query.column_int(0);
     EXPECT_GE(version, 11);
   }
 
   EXPECT_FALSE(file_util::PathExists(old_style_sync_data_path()));
 
   FilePath new_style_path = temp_dir.path().Append(
       syncable::DirectoryManager::GetSyncDataDatabaseFilename());
 
   std::string contents;
   ASSERT_TRUE(file_util::ReadFileToString(new_style_path, &contents));
   EXPECT_TRUE(sync_data() == contents);
-  sqlite3_close(handle);
 }
 
 TEST_F(UserSettingsTest, MigrateFromV11ToV12) {
   ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   SetUpVersion11Database(temp_dir.path());
   {
     UserSettings settings;
     settings.Init(v11_user_setting_db_path());
   }
   sqlite3* handle = NULL;
   ASSERT_EQ(SQLITE_OK, sqlite_utils::OpenSqliteDb(v11_user_setting_db_path(),
                                                   &handle));
+  sqlite_utils::scoped_sqlite_db_ptr db(handle);
 
   {
     SQLStatement version_query;
     version_query.prepare(handle, "SELECT version FROM db_version");
     ASSERT_EQ(SQLITE_ROW, version_query.step());
     const int version = version_query.column_int(0);
     EXPECT_GE(version, 12);
 
     SQLStatement table_query;
     table_query.prepare(handle, "SELECT name FROM sqlite_master "
         "WHERE type='table' AND name='signin_types'");
     ASSERT_NE(SQLITE_ROW, table_query.step());
   }
 }
 
 TEST_F(UserSettingsTest, APEncode) {
   string test;
   char i;
   for (i = numeric_limits<char>::min(); i < numeric_limits<char>::max(); ++i)
     test.push_back(i);
   test.push_back(i);
   const string encoded = APEncode(test);
   const string decoded = APDecode(encoded);
   ASSERT_EQ(test, decoded);
 }
+
+TEST_F(UserSettingsTest, PersistEmptyToken) {
+  ScopedTempDir temp_dir;
+  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
+  UserSettings settings;
+  settings.Init(temp_dir.path().AppendASCII("UserSettings.sqlite3"));
+  settings.SetAuthTokenForService("username", "service", "");
+  std::string username;
+  std::string token;
+  ASSERT_TRUE(settings.GetLastUserAndServiceToken("service", &username,
+      &token));
+  EXPECT_EQ("", token);
+  EXPECT_EQ("username", username);
+}
+
+TEST_F(UserSettingsTest, PersistNonEmptyToken) {
+  ScopedTempDir temp_dir;
+  ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
+  UserSettings settings;
+  settings.Init(temp_dir.path().AppendASCII("UserSettings.sqlite3"));
+  settings.SetAuthTokenForService("username", "service", "012345beefbeef");
+  std::string username;
+  std::string token;
+  ASSERT_TRUE(settings.GetLastUserAndServiceToken("service", &username,
+      &token));
+  EXPECT_EQ("012345beefbeef", token);
+  EXPECT_EQ("username", username);
+}