Remove obsolete sqlite_utils.h API

BUG=77634
R=tfarina@chromium.org


Review URL: http://codereview.chromium.org/9186042

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@118039 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 0 insertions, 898 deletions

diff --git a/chrome/browser/sync/syncable/DEPS b/chrome/browser/sync/syncable/DEPS
index 9946874..6f36d3c 100644
--- a/chrome/browser/sync/syncable/DEPS
+++ b/chrome/browser/sync/syncable/DEPS
@@ -16,7 +16,6 @@ include_rules = [
 
   # For the unrecoverable error handler stuff.
   "+chrome/common/random.h",
-  "+chrome/common/sqlite_utils.h",
 
   "-chrome/browser/sync/internal_api",
   "+chrome/browser/sync/internal_api/includes",
diff --git a/chrome/browser/sync/syncable/directory_backing_store_unittest.cc b/chrome/browser/sync/syncable/directory_backing_store_unittest.cc
index cf0ff26..59a2765 100644
--- a/chrome/browser/sync/syncable/directory_backing_store_unittest.cc
+++ b/chrome/browser/sync/syncable/directory_backing_store_unittest.cc
@@ -18,7 +18,6 @@
 #include "chrome/browser/sync/syncable/directory_manager.h"
 #include "chrome/browser/sync/syncable/syncable-inl.h"
 #include "chrome/browser/sync/syncable/syncable.h"
-#include "chrome/browser/sync/util/sqlite_utils.h"
 #include "chrome/browser/sync/util/time.h"
 #include "sql/connection.h"
 #include "sql/statement.h"
diff --git a/chrome/browser/sync/util/sqlite_utils.cc b/chrome/browser/sync/util/sqlite_utils.cc
deleted file mode 100644
index 7b75f0e..0000000
--- a/chrome/browser/sync/util/sqlite_utils.cc
+++ /dev/null
@@ -1,511 +0,0 @@
-// Copyright (c) 2011 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 "chrome/browser/sync/util/sqlite_utils.h"
-
-#include <list>
-
-#include "base/file_path.h"
-#include "base/lazy_instance.h"
-#include "base/logging.h"
-#include "base/stl_util.h"
-#include "base/string16.h"
-#include "base/synchronization/lock.h"
-
-namespace sqlite_utils {
-
-// The vanilla error handler implements the common fucntionality for all the
-// error handlers. Specialized error handlers are expected to only override
-// the Handler() function.
-class VanillaSQLErrorHandler : public SQLErrorHandler {
- public:
-  VanillaSQLErrorHandler() : error_(SQLITE_OK) {
-  }
-  virtual int GetLastError() const {
-    return error_;
-  }
- protected:
-  int error_;
-};
-
-class DebugSQLErrorHandler: public VanillaSQLErrorHandler {
- public:
-  virtual int HandleError(int error, sqlite3* db) {
-    error_ = error;
-    LOG(ERROR) << "sqlite error " << error
-               << " " << sqlite3_errmsg(db)
-               << " db " << static_cast<void*>(db);
-    return error;
-  }
-};
-
-class ReleaseSQLErrorHandler : public VanillaSQLErrorHandler {
- public:
-  virtual int HandleError(int error, sqlite3* db) {
-    error_ = error;
-    // Used to have a CHECK here. Got lots of crashes.
-    return error;
-  }
-};
-
-// The default error handler factory is also in charge of managing the
-// lifetime of the error objects. This object is multi-thread safe.
-class DefaultSQLErrorHandlerFactory : public SQLErrorHandlerFactory {
- public:
-  ~DefaultSQLErrorHandlerFactory() {
-    STLDeleteContainerPointers(errors_.begin(), errors_.end());
-  }
-
-  virtual SQLErrorHandler* Make() {
-    SQLErrorHandler* handler;
-#ifndef NDEBUG
-    handler = new DebugSQLErrorHandler;
-#else
-    handler = new ReleaseSQLErrorHandler;
-#endif  // NDEBUG
-    AddHandler(handler);
-    return handler;
-  }
-
- private:
-  void AddHandler(SQLErrorHandler* handler) {
-    base::AutoLock lock(lock_);
-    errors_.push_back(handler);
-  }
-
-  typedef std::list<SQLErrorHandler*> ErrorList;
-  ErrorList errors_;
-  base::Lock lock_;
-};
-
-static base::LazyInstance<DefaultSQLErrorHandlerFactory>
-    g_default_sql_error_handler_factory = LAZY_INSTANCE_INITIALIZER;
-
-SQLErrorHandlerFactory* GetErrorHandlerFactory() {
-  // TODO(cpu): Testing needs to override the error handler.
-  // Destruction of DefaultSQLErrorHandlerFactory handled by at_exit manager.
-  return g_default_sql_error_handler_factory.Pointer();
-}
-
-int OpenSqliteDb(const FilePath& filepath, sqlite3** database) {
-#if defined(OS_WIN)
-  // We want the default encoding to always be UTF-8, so we use the
-  // 8-bit version of open().
-  return sqlite3_open(WideToUTF8(filepath.value()).c_str(), database);
-#elif defined(OS_POSIX)
-  return sqlite3_open(filepath.value().c_str(), database);
-#endif
-}
-
-bool DoesSqliteTableExist(sqlite3* db,
-                          const char* db_name,
-                          const char* table_name) {
-  // sqlite doesn't allow binding parameters as table names, so we have to
-  // manually construct the sql
-  std::string sql("SELECT name FROM ");
-  if (db_name && db_name[0]) {
-    sql.append(db_name);
-    sql.push_back('.');
-  }
-  sql.append("sqlite_master WHERE type='table' AND name=?");
-
-  SQLStatement statement;
-  if (statement.prepare(db, sql.c_str()) != SQLITE_OK)
-    return false;
-
-  if (statement.bind_text(0, table_name) != SQLITE_OK)
-    return false;
-
-  // we only care about if this matched a row, not the actual data
-  return sqlite3_step(statement.get()) == SQLITE_ROW;
-}
-
-bool DoesSqliteColumnExist(sqlite3* db,
-                           const char* database_name,
-                           const char* table_name,
-                           const char* column_name,
-                           const char* column_type) {
-  SQLStatement s;
-  std::string sql;
-  sql.append("PRAGMA ");
-  if (database_name && database_name[0]) {
-    // optional database name specified
-    sql.append(database_name);
-    sql.push_back('.');
-  }
-  sql.append("TABLE_INFO(");
-  sql.append(table_name);
-  sql.append(")");
-
-  if (s.prepare(db, sql.c_str()) != SQLITE_OK)
-    return false;
-
-  while (s.step() == SQLITE_ROW) {
-    if (!s.column_string(1).compare(column_name)) {
-      if (column_type && column_type[0])
-        return !s.column_string(2).compare(column_type);
-      return true;
-    }
-  }
-  return false;
-}
-
-bool DoesSqliteTableHaveRow(sqlite3* db, const char* table_name) {
-  SQLStatement s;
-  std::string b;
-  b.append("SELECT * FROM ");
-  b.append(table_name);
-
-  if (s.prepare(db, b.c_str()) != SQLITE_OK)
-    return false;
-
-  return s.step() == SQLITE_ROW;
-}
-
-SQLTransaction::SQLTransaction(sqlite3* db) : db_(db), began_(false) {
-}
-
-SQLTransaction::~SQLTransaction() {
-  if (began_) {
-    Rollback();
-  }
-}
-
-int SQLTransaction::BeginCommand(const char* command) {
-  int rv = SQLITE_ERROR;
-  if (!began_ && db_) {
-    rv = sqlite3_exec(db_, command, NULL, NULL, NULL);
-    began_ = (rv == SQLITE_OK);
-  }
-  return rv;
-}
-
-int SQLTransaction::EndCommand(const char* command) {
-  int rv = SQLITE_ERROR;
-  if (began_ && db_) {
-    rv = sqlite3_exec(db_, command, NULL, NULL, NULL);
-    began_ = (rv != SQLITE_OK);
-  }
-  return rv;
-}
-
-SQLNestedTransactionSite::~SQLNestedTransactionSite() {
-  DCHECK(!top_transaction_);
-}
-
-void SQLNestedTransactionSite::SetTopTransaction(SQLNestedTransaction* top) {
-  DCHECK(!top || !top_transaction_);
-  top_transaction_ = top;
-}
-
-SQLNestedTransaction::SQLNestedTransaction(SQLNestedTransactionSite* site)
-  : SQLTransaction(site->GetSqlite3DB()),
-    needs_rollback_(false),
-    site_(site) {
-  DCHECK(site);
-  if (site->GetTopTransaction() == NULL) {
-    site->SetTopTransaction(this);
-  }
-}
-
-SQLNestedTransaction::~SQLNestedTransaction() {
-  if (began_) {
-    Rollback();
-  }
-  if (site_->GetTopTransaction() == this) {
-    site_->SetTopTransaction(NULL);
-  }
-}
-
-int SQLNestedTransaction::BeginCommand(const char* command) {
-  DCHECK(db_);
-  DCHECK(site_ && site_->GetTopTransaction());
-  if (!db_ || began_) {
-    return SQLITE_ERROR;
-  }
-  if (site_->GetTopTransaction() == this) {
-    int rv = sqlite3_exec(db_, command, NULL, NULL, NULL);
-    began_ = (rv == SQLITE_OK);
-    if (began_) {
-      site_->OnBegin();
-    }
-    return rv;
-  } else {
-    if (site_->GetTopTransaction()->needs_rollback_) {
-      return SQLITE_ERROR;
-    }
-    began_ = true;
-    return SQLITE_OK;
-  }
-}
-
-int SQLNestedTransaction::EndCommand(const char* command) {
-  DCHECK(db_);
-  DCHECK(site_ && site_->GetTopTransaction());
-  if (!db_ || !began_) {
-    return SQLITE_ERROR;
-  }
-  if (site_->GetTopTransaction() == this) {
-    if (needs_rollback_) {
-      sqlite3_exec(db_, "ROLLBACK", NULL, NULL, NULL);
-      began_ = false;  // reset so we don't try to rollback or call
-                       // OnRollback() again
-      site_->OnRollback();
-      return SQLITE_ERROR;
-    } else {
-      int rv = sqlite3_exec(db_, command, NULL, NULL, NULL);
-      began_ = (rv != SQLITE_OK);
-      if (strcmp(command, "ROLLBACK") == 0) {
-        began_ = false;  // reset so we don't try to rollbck or call
-                         // OnRollback() again
-        site_->OnRollback();
-      } else {
-        DCHECK(strcmp(command, "COMMIT") == 0);
-        if (rv == SQLITE_OK) {
-          site_->OnCommit();
-        }
-      }
-      return rv;
-    }
-  } else {
-    if (strcmp(command, "ROLLBACK") == 0) {
-      site_->GetTopTransaction()->needs_rollback_ = true;
-    }
-    began_ = false;
-    return SQLITE_OK;
-  }
-}
-
-int SQLStatement::prepare(sqlite3* db, const char* sql, int sql_len) {
-  DCHECK(!stmt_);
-  int rv = sqlite3_prepare_v2(db, sql, sql_len, &stmt_, NULL);
-  if (rv != SQLITE_OK) {
-    SQLErrorHandler* error_handler = GetErrorHandlerFactory()->Make();
-    return error_handler->HandleError(rv, db);
-  }
-  return rv;
-}
-
-int SQLStatement::step() {
-  DCHECK(stmt_);
-  int status = sqlite3_step(stmt_);
-  if ((status == SQLITE_ROW) || (status == SQLITE_DONE))
-    return status;
-  // We got a problem.
-  SQLErrorHandler* error_handler = GetErrorHandlerFactory()->Make();
-  return error_handler->HandleError(status, db_handle());
-}
-
-int SQLStatement::reset() {
-  DCHECK(stmt_);
-  return sqlite3_reset(stmt_);
-}
-
-sqlite_int64 SQLStatement::last_insert_rowid() {
-  DCHECK(stmt_);
-  return sqlite3_last_insert_rowid(db_handle());
-}
-
-int SQLStatement::changes() {
-  DCHECK(stmt_);
-  return sqlite3_changes(db_handle());
-}
-
-sqlite3* SQLStatement::db_handle() {
-  DCHECK(stmt_);
-  return sqlite3_db_handle(stmt_);
-}
-
-int SQLStatement::bind_parameter_count() {
-  DCHECK(stmt_);
-  return sqlite3_bind_parameter_count(stmt_);
-}
-
-int SQLStatement::bind_blob(int index, std::vector<unsigned char>* blob) {
-  if (blob) {
-    const void* value = blob->empty() ? NULL : &(*blob)[0];
-    int len = static_cast<int>(blob->size());
-    return bind_blob(index, value, len);
-  } else {
-    return bind_null(index);
-  }
-}
-
-int SQLStatement::bind_blob(int index, const void* value, int value_len) {
-   return bind_blob(index, value, value_len, SQLITE_TRANSIENT);
-}
-
-int SQLStatement::bind_blob(int index, const void* value, int value_len,
-                            Function dtor) {
-  DCHECK(stmt_);
-  return sqlite3_bind_blob(stmt_, index + 1, value, value_len, dtor);
-}
-
-int SQLStatement::bind_double(int index, double value) {
-  DCHECK(stmt_);
-  return sqlite3_bind_double(stmt_, index + 1, value);
-}
-
-int SQLStatement::bind_bool(int index, bool value) {
-  DCHECK(stmt_);
-  return sqlite3_bind_int(stmt_, index + 1, value);
-}
-
-int SQLStatement::bind_int(int index, int value) {
-  DCHECK(stmt_);
-  return sqlite3_bind_int(stmt_, index + 1, value);
-}
-
-int SQLStatement::bind_int64(int index, sqlite_int64 value) {
-  DCHECK(stmt_);
-  return sqlite3_bind_int64(stmt_, index + 1, value);
-}
-
-int SQLStatement::bind_null(int index) {
-  DCHECK(stmt_);
-  return sqlite3_bind_null(stmt_, index + 1);
-}
-
-int SQLStatement::bind_text(int index, const char* value, int value_len,
-              Function dtor) {
-  DCHECK(stmt_);
-  return sqlite3_bind_text(stmt_, index + 1, value, value_len, dtor);
-}
-
-int SQLStatement::bind_text16(int index, const char16* value, int value_len,
-                Function dtor) {
-  DCHECK(stmt_);
-  value_len *= sizeof(char16);
-  return sqlite3_bind_text16(stmt_, index + 1, value, value_len, dtor);
-}
-
-int SQLStatement::bind_value(int index, const sqlite3_value* value) {
-  DCHECK(stmt_);
-  return sqlite3_bind_value(stmt_, index + 1, value);
-}
-
-int SQLStatement::column_count() {
-  DCHECK(stmt_);
-  return sqlite3_column_count(stmt_);
-}
-
-int SQLStatement::column_type(int index) {
-  DCHECK(stmt_);
-  return sqlite3_column_type(stmt_, index);
-}
-
-const void* SQLStatement::column_blob(int index) {
-  DCHECK(stmt_);
-  return sqlite3_column_blob(stmt_, index);
-}
-
-bool SQLStatement::column_blob_as_vector(int index,
-                                         std::vector<unsigned char>* blob) {
-  DCHECK(stmt_);
-  const void* p = column_blob(index);
-  size_t len = column_bytes(index);
-  blob->resize(len);
-  if (blob->size() != len) {
-    return false;
-  }
-  if (len > 0)
-    memcpy(&(blob->front()), p, len);
-  return true;
-}
-
-bool SQLStatement::column_blob_as_string(int index, std::string* blob) {
-  DCHECK(stmt_);
-  const void* p = column_blob(index);
-  size_t len = column_bytes(index);
-  blob->resize(len);
-  if (blob->size() != len) {
-    return false;
-  }
-  blob->assign(reinterpret_cast<const char*>(p), len);
-  return true;
-}
-
-int SQLStatement::column_bytes(int index) {
-  DCHECK(stmt_);
-  return sqlite3_column_bytes(stmt_, index);
-}
-
-int SQLStatement::column_bytes16(int index) {
-  DCHECK(stmt_);
-  return sqlite3_column_bytes16(stmt_, index);
-}
-
-double SQLStatement::column_double(int index) {
-  DCHECK(stmt_);
-  return sqlite3_column_double(stmt_, index);
-}
-
-bool SQLStatement::column_bool(int index) {
-  DCHECK(stmt_);
-  return sqlite3_column_int(stmt_, index) ? true : false;
-}
-
-int SQLStatement::column_int(int index) {
-  DCHECK(stmt_);
-  return sqlite3_column_int(stmt_, index);
-}
-
-sqlite_int64 SQLStatement::column_int64(int index) {
-  DCHECK(stmt_);
-  return sqlite3_column_int64(stmt_, index);
-}
-
-const char* SQLStatement::column_text(int index) {
-  DCHECK(stmt_);
-  return reinterpret_cast<const char*>(sqlite3_column_text(stmt_, index));
-}
-
-bool SQLStatement::column_string(int index, std::string* str) {
-  DCHECK(stmt_);
-  DCHECK(str);
-  const char* s = column_text(index);
-  str->assign(s ? s : std::string());
-  return s != NULL;
-}
-
-std::string SQLStatement::column_string(int index) {
-  std::string str;
-  column_string(index, &str);
-  return str;
-}
-
-const char16* SQLStatement::column_text16(int index) {
-  DCHECK(stmt_);
-  return static_cast<const char16*>(sqlite3_column_text16(stmt_, index));
-}
-
-bool SQLStatement::column_string16(int index, string16* str) {
-  DCHECK(stmt_);
-  DCHECK(str);
-  const char* s = column_text(index);
-  str->assign(s ? UTF8ToUTF16(s) : string16());
-  return (s != NULL);
-}
-
-string16 SQLStatement::column_string16(int index) {
-  string16 str;
-  column_string16(index, &str);
-  return str;
-}
-
-bool SQLStatement::column_wstring(int index, std::wstring* str) {
-  DCHECK(stmt_);
-  DCHECK(str);
-  const char* s = column_text(index);
-  str->assign(s ? UTF8ToWide(s) : std::wstring());
-  return (s != NULL);
-}
-
-std::wstring SQLStatement::column_wstring(int index) {
-  std::wstring wstr;
-  column_wstring(index, &wstr);
-  return wstr;
-}
-
-}  // namespace sqlite_utils
diff --git a/chrome/browser/sync/util/sqlite_utils.h b/chrome/browser/sync/util/sqlite_utils.h
deleted file mode 100644
index 8eb219c..0000000
--- a/chrome/browser/sync/util/sqlite_utils.h
+++ /dev/null
@@ -1,383 +0,0 @@
-// Copyright (c) 2011 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.
-
-#ifndef CHROME_BROWSER_SYNC_UTIL_SQLITE_UTILS_H_
-#define CHROME_BROWSER_SYNC_UTIL_SQLITE_UTILS_H_
-#pragma once
-
-#include <string>
-#include <vector>
-
-#include "base/basictypes.h"
-#include "base/compiler_specific.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/string16.h"
-#include "base/utf_string_conversions.h"
-#include "third_party/sqlite/sqlite3.h"
-
-class FilePath;
-
-namespace sqlite_utils {
-
-class SQLTransaction;
-class SQLNestedTransaction;
-class SQLNestedTransactionSite;
-class scoped_sqlite3_stmt_ptr;
-class SQLStatement;
-
-// Interface to be implemented by objects that can handle exceptional sqlite
-// conditions. This way client code can focus on handling normal condtions.
-class SQLErrorHandler {
- public:
-  virtual ~SQLErrorHandler() {}
-  // Handle a sqlite error. |error| is the return code an of sqlite operation
-  // which is considered an error. This handler is free to try repair, notify
-  // someone or even break into the debugger depending on the situation.
-  virtual int HandleError(int error, sqlite3* db) = 0;
-  // Returns the last value of |error| passed to HandleError.
-  virtual int GetLastError() const = 0;
-};
-
-// The factory interface is used to create the different error handling
-// strategies for debug, release and for diagnostic mode.
-class SQLErrorHandlerFactory {
- public:
-  virtual ~SQLErrorHandlerFactory() {}
-  virtual SQLErrorHandler* Make() = 0;
-};
-
-// A wrapper for sqlite transactions that rollsback when the wrapper goes out of
-// scope if the caller has not already called Commit or Rollback.
-// Note: the constructor does NOT Begin a transaction.
-class SQLTransaction {
- public:
-  explicit SQLTransaction(sqlite3* db);
-  virtual ~SQLTransaction();
-
-  int Begin() {
-    // By default, we BEGIN IMMEDIATE to establish file locks at the
-    // onset of a transaction. This avoids SQLITE_BUSY errors, without
-    // waiting for the busy timeout period, which can occur when BEGIN
-    // DEFERRED is used.
-    return BeginImmediate();
-  }
-
-  int BeginExclusive() {
-    return BeginCommand("BEGIN EXCLUSIVE");
-  }
-
-  int BeginImmediate() {
-    return BeginCommand("BEGIN IMMEDIATE");
-  }
-
-  int BeginDeferred() {
-    return BeginCommand("BEGIN DEFERRED");
-  }
-
-  int Commit() {
-    return EndCommand("COMMIT");
-  }
-
-  int Rollback() {
-    return EndCommand("ROLLBACK");
-  }
-
-  bool HasBegun() {
-    return began_;
-  }
-
- protected:
-  virtual int BeginCommand(const char* command);
-  virtual int EndCommand(const char* command);
-
-  sqlite3* db_;
-  bool began_;
-  DISALLOW_COPY_AND_ASSIGN(SQLTransaction);
-};
-
-// A class for use with SQLNestedTransaction.
-class SQLNestedTransactionSite {
- protected:
-  SQLNestedTransactionSite() : db_(NULL), top_transaction_(NULL) {}
-  virtual ~SQLNestedTransactionSite();
-
-  // The following virtual methods provide notification of true transaction
-  // boundaries as they are crossed by a top nested transaction.
-  // Intended to be overriden (See WebCacheDB)
-  // SQLNestedTransaction calls these after the underlying database
-  // operation has been performed.
-
-  virtual void OnBegin() {}
-  virtual void OnCommit() {}
-  virtual void OnRollback() {}
-
-  // Returns the sqlite3 database connection associated with this site
-  // Used by SQLNestedTransaction
-  sqlite3* GetSqlite3DB() { return db_; }
-
-  // Returns the current top nested transaction associated with this site
-  // Used by SQLNestedTransaction
-  SQLNestedTransaction* GetTopTransaction() {
-    return top_transaction_;
-  }
-
-  // Sets or clears the top nested transaction associated with this site
-  // Used by SQLNestedTransaction
-  void SetTopTransaction(SQLNestedTransaction* top);
-
-  sqlite3* db_;
-  SQLNestedTransaction* top_transaction_;
-  friend class SQLNestedTransaction;
-};
-
-// SQLite does not support nested transactions. This class provides a gross
-// approximation of nested transactions.
-//
-// Really there is only one transaction, the top transaction.
-//
-// A nested transaction commits with respect to the top transaction.
-// That is, even though the nested transaction commits, the permanence of its
-// effects depends on the top transaction committing. If the top
-// transaction rollsback, the results of the nested transaction are backed out.
-// If any nested transaction aborts, the top transaction ultimately rollsback
-// as well.
-//
-// Note: If a nested transaction is open for a particular db connection, an
-// attempt to open a non-nested transaction (class SQLTransaction) will fail.
-// And vice versa.
-//
-// TODO(michaeln): demonstrate usage here
-// TODO(michaeln): safegaurds to prevent mis-use
-class SQLNestedTransaction : public SQLTransaction {
- public:
-  explicit SQLNestedTransaction(SQLNestedTransactionSite* site);
-  virtual ~SQLNestedTransaction();
-
- protected:
-  virtual int BeginCommand(const char* command) OVERRIDE;
-  virtual int EndCommand(const char* command) OVERRIDE;
-
- private:
-  bool needs_rollback_;
-  SQLNestedTransactionSite* site_;
-  DISALLOW_COPY_AND_ASSIGN(SQLNestedTransaction);
-};
-
-// A scoped sqlite statement that finalizes when it goes out of scope.
-class scoped_sqlite3_stmt_ptr {
- public:
-  ~scoped_sqlite3_stmt_ptr() {
-    finalize();
-  }
-
-  scoped_sqlite3_stmt_ptr() : stmt_(NULL) {
-  }
-
-  explicit scoped_sqlite3_stmt_ptr(sqlite3_stmt* stmt)
-    : stmt_(stmt) {
-  }
-
-  sqlite3_stmt* get() const {
-    return stmt_;
-  }
-
-  void set(sqlite3_stmt* stmt) {
-    finalize();
-    stmt_ = stmt;
-  }
-
-  sqlite3_stmt* release() {
-    sqlite3_stmt* tmp = stmt_;
-    stmt_ = NULL;
-    return tmp;
-  }
-
-  // It is not safe to call sqlite3_finalize twice on the same stmt.
-  // Sqlite3's sqlite3_finalize() function should not be called directly
-  // without calling the release method.  If sqlite3_finalize() must be
-  // called directly, the following usage is advised:
-  //  scoped_sqlite3_stmt_ptr stmt;
-  //  ... do something with stmt ...
-  //  sqlite3_finalize(stmt.release());
-  int finalize() {
-    int err = sqlite3_finalize(stmt_);
-    stmt_ = NULL;
-    return err;
-  }
-
- protected:
-  sqlite3_stmt* stmt_;
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(scoped_sqlite3_stmt_ptr);
-};
-
-// A scoped sqlite statement with convenient C++ wrappers for sqlite3 APIs.
-class SQLStatement : public scoped_sqlite3_stmt_ptr {
- public:
-  SQLStatement() {}
-
-  int prepare(sqlite3* db, const char* sql) {
-    return prepare(db, sql, -1);
-  }
-
-  int prepare(sqlite3* db, const char* sql, int sql_len);
-
-  int step();
-  int reset();
-  sqlite_int64 last_insert_rowid();
-  int changes();
-  sqlite3* db_handle();
-
-  //
-  // Parameter binding helpers (NOTE: index is 0-based)
-  //
-
-  int bind_parameter_count();
-
-  typedef void (*Function)(void*);
-
-  int bind_blob(int index, std::vector<unsigned char>* blob);
-  int bind_blob(int index, const void* value, int value_len);
-  int bind_blob(int index, const void* value, int value_len, Function dtor);
-  int bind_double(int index, double value);
-  int bind_bool(int index, bool value);
-  int bind_int(int index, int value);
-  int bind_int64(int index, sqlite_int64 value);
-  int bind_null(int index);
-
-  int bind_string(int index, const std::string& value) {
-    // don't use c_str so it doesn't have to fix up the null terminator
-    // (sqlite just uses the length)
-    return bind_text(index, value.data(),
-                     static_cast<int>(value.length()), SQLITE_TRANSIENT);
-  }
-
-  int bind_string16(int index, const string16& value) {
-    // don't use c_str so it doesn't have to fix up the null terminator
-    // (sqlite just uses the length)
-    std::string value_utf8(UTF16ToUTF8(value));
-    return bind_text(index, value_utf8.data(),
-                     static_cast<int>(value_utf8.length()), SQLITE_TRANSIENT);
-  }
-
-  int bind_wstring(int index, const std::wstring& value) {
-    // don't use c_str so it doesn't have to fix up the null terminator
-    // (sqlite just uses the length)
-    std::string value_utf8(WideToUTF8(value));
-    return bind_text(index, value_utf8.data(),
-                     static_cast<int>(value_utf8.length()), SQLITE_TRANSIENT);
-  }
-
-  int bind_text(int index, const char* value) {
-    return bind_text(index, value, -1, SQLITE_TRANSIENT);
-  }
-
-  // value_len is number of characters or may be negative
-  // a for null-terminated value string
-  int bind_text(int index, const char* value, int value_len) {
-    return bind_text(index, value, value_len, SQLITE_TRANSIENT);
-  }
-
-  // value_len is number of characters or may be negative
-  // a for null-terminated value string
-  int bind_text(int index, const char* value, int value_len,
-                Function dtor);
-
-  int bind_text16(int index, const char16* value) {
-    return bind_text16(index, value, -1, SQLITE_TRANSIENT);
-  }
-
-  // value_len is number of characters or may be negative
-  // a for null-terminated value string
-  int bind_text16(int index, const char16* value, int value_len) {
-    return bind_text16(index, value, value_len, SQLITE_TRANSIENT);
-  }
-
-  // value_len is number of characters or may be negative
-  // a for null-terminated value string
-  int bind_text16(int index, const char16* value, int value_len,
-                  Function dtor);
-
-  int bind_value(int index, const sqlite3_value* value);
-
-  //
-  // Column helpers (NOTE: index is 0-based).
-  //
-  int column_count();
-  int column_type(int index);
-  const void* column_blob(int index);
-  bool column_blob_as_vector(int index, std::vector<unsigned char>* blob);
-  bool column_blob_as_string(int index, std::string* blob);
-  int column_bytes(int index);
-  int column_bytes16(int index);
-  double column_double(int index);
-  bool column_bool(int index);
-  int column_int(int index);
-  sqlite_int64 column_int64(int index);
-  const char* column_text(int index);
-  bool column_string(int index, std::string* str);
-  std::string column_string(int index);
-  const char16* column_text16(int index);
-  bool column_string16(int index, string16* str);
-  string16 column_string16(int index);
-  bool column_wstring(int index, std::wstring* str);
-  std::wstring column_wstring(int index);
-
- private:
-  DISALLOW_COPY_AND_ASSIGN(SQLStatement);
-};
-
-// A scoped sqlite database that closes when it goes out of scope.
-class DBClose {
- public:
-  inline void operator()(sqlite3* x) const {
-    sqlite3_close(x);
-  }
-};
-
-typedef scoped_ptr_malloc<sqlite3, DBClose> scoped_sqlite_db_ptr;
-
-// Opens the DB in the file pointed to by |filepath|.  This method forces the
-// database to be in UTF-8 mode on all platforms. See
-// http://www.sqlite.org/capi3ref.html#sqlite3_open for an explanation of the
-// return value.
-int OpenSqliteDb(const FilePath& filepath, sqlite3** database);
-
-// Returns true if there is a table with the given name in the database.
-// For the version where a database name is specified, it may be NULL or the
-// empty string if no database name is necessary.
-bool DoesSqliteTableExist(sqlite3* db,
-                          const char* db_name,
-                          const char* table_name);
-inline bool DoesSqliteTableExist(sqlite3* db, const char* table_name) {
-  return DoesSqliteTableExist(db, NULL, table_name);
-}
-
-// Test whether a table has a column matching the provided name and type.
-// Returns true if the column exist and false otherwise. There are two
-// versions, one that takes a database name, the other that doesn't. The
-// database name can be NULL or empty if no name is desired.
-//
-// Column type is optional, it can be NULL or empty. If specified, we the
-// function will check that the column is of the correct type (case-sensetive).
-bool DoesSqliteColumnExist(sqlite3* db,
-                           const char* datbase_name,
-                           const char* table_name,
-                           const char* column_name,
-                           const char* column_type);
-inline bool DoesSqliteColumnExist(sqlite3* db,
-                           const char* table_name,
-                           const char* column_name,
-                           const char* column_type) {
-  return DoesSqliteColumnExist(db, NULL, table_name, column_name, column_type);
-}
-
-// Test whether a table has one or more rows. Returns true if the table
-// has one or more rows and false if the table is empty or doesn't exist.
-bool DoesSqliteTableHaveRow(sqlite3* db, const char* table_name);
-
-}  // namespace sqlite_utils
-
-#endif  // CHROME_BROWSER_SYNC_UTIL_SQLITE_UTILS_H_
diff --git a/chrome/chrome.gyp b/chrome/chrome.gyp
index 59db3d397c..40a1021 100644
--- a/chrome/chrome.gyp
+++ b/chrome/chrome.gyp
@@ -492,8 +492,6 @@
         'browser/sync/util/nigori.h',
         'browser/sync/util/oauth.cc',
         'browser/sync/util/oauth.h',
-        'browser/sync/util/sqlite_utils.cc',
-        'browser/sync/util/sqlite_utils.h',
         'browser/sync/util/time.cc',
         'browser/sync/util/time.h',
         'browser/sync/util/unrecoverable_error_info.h',