More SQL statement usage regularization. Back-touch some

chrome/browser/importer/firefox3_importer.cc

 // 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/importer/firefox3_importer.h"
 
 #include <set>
 
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 111 matching lines @@
   // redirects, since we don't want them to appear in history.
   // Firefox transition types are defined in:
   //   toolkit/components/places/public/nsINavHistoryService.idl
   const char* query = "SELECT h.url, h.title, h.visit_count, "
                       "h.hidden, h.typed, v.visit_date "
                       "FROM moz_places h JOIN moz_historyvisits v "
                       "ON h.id = v.place_id "
                       "WHERE v.visit_type <= 3";
 
   sql::Statement s(db.GetUniqueStatement(query));
-  if (!s)
-    return;
 
   std::vector<history::URLRow> rows;
   while (s.Step() && !cancelled()) {
     GURL url(s.ColumnString(0));
 
     // Filter out unwanted URLs.
     if (!CanImportURL(url))
       continue;
 
     history::URLRow row(url);
@@ skipping 46 matching lines @@
   FaviconMap favicon_map;
 
   // TODO(jcampan): http://b/issue?id=1196285 we do not support POST based
   //                keywords yet.  We won't include them in the list.
   std::set<int> post_keyword_ids;
   const char* query = "SELECT b.id FROM moz_bookmarks b "
       "INNER JOIN moz_items_annos ia ON ia.item_id = b.id "
       "INNER JOIN moz_anno_attributes aa ON ia.anno_attribute_id = aa.id "
       "WHERE aa.name = 'bookmarkProperties/POSTData'";
   sql::Statement s(db.GetUniqueStatement(query));
-  if (s) {
-    while (s.Step() && !cancelled())
-      post_keyword_ids.insert(s.ColumnInt(0));
-  } else {
-    NOTREACHED();
+
+  if (!s.is_valid())
     return;
-  }
+
+  while (s.Step() && !cancelled())
+    post_keyword_ids.insert(s.ColumnInt(0));
 
   for (size_t i = 0; i < list.size(); ++i) {
     BookmarkItem* item = list[i];
 
     if (item->type == TYPE_FOLDER) {
       // Folders are added implicitly on adding children, so we only explicitly
       // add empty folders.
       if (!item->empty_folder)
         continue;
     } else if (item->type == TYPE_BOOKMARK) {
@@ skipping 146 matching lines @@
   if (!db.Open(file))
     return;
 
   const char* query = "SELECT engineid FROM engine_data "
                       "WHERE engineid NOT IN "
                       "(SELECT engineid FROM engine_data "
                       "WHERE name='hidden') "
                       "ORDER BY value ASC";
 
   sql::Statement s(db.GetUniqueStatement(query));
-  if (!s)
+  if (!s.is_valid())
     return;
 
   FilePath app_path = app_path_.AppendASCII("searchplugins");
   FilePath profile_path = source_path_.AppendASCII("searchplugins");
 
   // Firefox doesn't store a search engine in its sqlite database unless the
   // user has added a engine. So we get search engines from sqlite db as well
   // as from the file system.
   if (s.Step()) {
     const std::string kAppPrefix("[app]/");
@@ skipping 51 matching lines @@
 void Firefox3Importer::LoadRootNodeID(sql::Connection* db,
                                       int* toolbar_folder_id,
                                       int* menu_folder_id,
                                       int* unsorted_folder_id) {
   static const char* kToolbarFolderName = "toolbar";
   static const char* kMenuFolderName = "menu";
   static const char* kUnsortedFolderName = "unfiled";
 
   const char* query = "SELECT root_name, folder_id FROM moz_bookmarks_roots";
   sql::Statement s(db->GetUniqueStatement(query));
-  if (!s)
-    return;
 
   while (s.Step()) {
     std::string folder = s.ColumnString(0);
     int id = s.ColumnInt(1);
     if (folder == kToolbarFolderName)
       *toolbar_folder_id = id;
     else if (folder == kMenuFolderName)
       *menu_folder_id = id;
     else if (folder == kUnsortedFolderName)
       *unsorted_folder_id = id;
   }
 }
 
 void Firefox3Importer::LoadLivemarkIDs(sql::Connection* db,
                                        std::set<int>* livemark) {
   static const char* kFeedAnnotation = "livemark/feedURI";
   livemark->clear();
 
   const char* query = "SELECT b.item_id "
                       "FROM moz_anno_attributes a "
                       "JOIN moz_items_annos b ON a.id = b.anno_attribute_id "
                       "WHERE a.name = ? ";
   sql::Statement s(db->GetUniqueStatement(query));
-  if (!s)
-    return;
+  s.BindString(0, kFeedAnnotation);
 
-  s.BindString(0, kFeedAnnotation);
   while (s.Step() && !cancelled())
     livemark->insert(s.ColumnInt(0));
 }
 
 void Firefox3Importer::GetTopBookmarkFolder(sql::Connection* db,
                                             int folder_id,
                                             BookmarkList* list) {
   const char* query = "SELECT b.title "
                      "FROM moz_bookmarks b "
                      "WHERE b.type = 2 AND b.id = ? "
                      "ORDER BY b.position";
   sql::Statement s(db->GetUniqueStatement(query));
-  if (!s)
-    return;
+  s.BindInt(0, folder_id);
 
-  s.BindInt(0, folder_id);
   if (s.Step()) {
     BookmarkItem* item = new BookmarkItem;
     item->parent = -1;  // The top level folder has no parent.
     item->id = folder_id;
     item->title = s.ColumnString16(0);
     item->type = TYPE_FOLDER;
     item->favicon = 0;
     item->empty_folder = true;
     list->push_back(item);
   }
 }
 
 void Firefox3Importer::GetWholeBookmarkFolder(sql::Connection* db,
                                               BookmarkList* list,
                                               size_t position,
                                               bool* empty_folder) {
   if (position >= list->size()) {
     NOTREACHED();
     return;
   }
 
   const char* query = "SELECT b.id, h.url, COALESCE(b.title, h.title), "
          "b.type, k.keyword, b.dateAdded, h.favicon_id "
          "FROM moz_bookmarks b "
          "LEFT JOIN moz_places h ON b.fk = h.id "
          "LEFT JOIN moz_keywords k ON k.id = b.keyword_id "
          "WHERE b.type IN (1,2) AND b.parent = ? "
          "ORDER BY b.position";
   sql::Statement s(db->GetUniqueStatement(query));
-  if (!s)
-    return;
+  s.BindInt(0, (*list)[position]->id);
 
-  s.BindInt(0, (*list)[position]->id);
   BookmarkList temp_list;
   while (s.Step()) {
     BookmarkItem* item = new BookmarkItem;
     item->parent = static_cast<int>(position);
     item->id = s.ColumnInt(0);
     item->url = GURL(s.ColumnString(1));
     item->title = s.ColumnString16(2);
     item->type = static_cast<BookmarkItemType>(s.ColumnInt(3));
     item->keyword = s.ColumnString(4);
     item->date_added = base::Time::FromTimeT(s.ColumnInt64(5)/1000000);
@@ skipping 14 matching lines @@
       GetWholeBookmarkFolder(db, list, list->size() - 1, &(*i)->empty_folder);
   }
 }
 
 void Firefox3Importer::LoadFavicons(
     sql::Connection* db,
     const FaviconMap& favicon_map,
     std::vector<history::ImportedFaviconUsage>* favicons) {
   const char* query = "SELECT url, data FROM moz_favicons WHERE id=?";
   sql::Statement s(db->GetUniqueStatement(query));
-  if (!s)
+
+  if (!s.is_valid())
     return;
 
   for (FaviconMap::const_iterator i = favicon_map.begin();
        i != favicon_map.end(); ++i) {
     s.BindInt64(0, i->first);
     if (s.Step()) {
       history::ImportedFaviconUsage usage;
 
       usage.favicon_url = GURL(s.ColumnString(0));
       if (!usage.favicon_url.is_valid())
         continue;  // Don't bother importing favicons with invalid URLs.
 
       std::vector<unsigned char> data;
       s.ColumnBlobAsVector(1, &data);
       if (data.empty())
         continue;  // Data definitely invalid.
 
       if (!importer::ReencodeFavicon(&data[0], data.size(), &usage.png_data))
         continue;  // Unable to decode.
 
       usage.urls = i->second;
       favicons->push_back(usage);
     }
     s.Reset();
   }
 }