Importer - Change const char* foo to const char foo[]

chrome/utility/importer/firefox_importer.cc

 // Copyright 2013 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/utility/importer/firefox_importer.h"
 
 #include <set>
 
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
@@ skipping 145 matching lines @@
 
   sql::Connection db;
   if (!db.Open(file))
     return;
 
   // |visit_type| represent the transition type of URLs (typed, click,
   // redirect, bookmark, etc.) We eliminate some URLs like sub-frames and
   // 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";
+  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));
 
   std::vector<ImporterURLRow> rows;
   while (s.Step() && !cancelled()) {
     GURL url(s.ColumnString(0));
 
     // Filter out unwanted URLs.
     if (!CanImportURL(url))
       continue;
@@ skipping 43 matching lines @@
   for (size_t i = 0; i < count; ++i)
     GetWholeBookmarkFolder(&db, &list, i, NULL);
 
   std::vector<ImportedBookmarkEntry> bookmarks;
   std::vector<importer::URLKeywordInfo> url_keywords;
   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 "
+  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.is_valid())
     return;
 
   while (s.Step() && !cancelled())
     post_keyword_ids.insert(s.ColumnInt(0));
@@ skipping 185 matching lines @@
     // Since Firefox 3.5, search engines are no longer stored in search.sqlite.
     // Instead, search.json is used for storing search engines.
     GetSearchEnginesXMLDataFromJSON(search_engine_data);
     return;
   }
 
   sql::Connection db;
   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";
+  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.is_valid())
     return;
 
   const base::FilePath searchplugins_path(FILE_PATH_LITERAL("searchplugins"));
   // Search engine definitions are XMLs stored in two directories. Default
   // engines are in the app directory (app_path_) and custom engines are
   // in the profile directory (source_path_).
 
@@ skipping 177 matching lines @@
 }
 
 void FirefoxImporter::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";
+  const char query[] = "SELECT root_name, folder_id FROM moz_bookmarks_roots";
   sql::Statement s(db->GetUniqueStatement(query));
 
   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 FirefoxImporter::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 = ? ";
+  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));
   s.BindString(0, kFeedAnnotation);
 
   while (s.Step() && !cancelled())
     livemark->insert(s.ColumnInt(0));
 }
 
 void FirefoxImporter::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";
+  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));
   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 FirefoxImporter::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";
+  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));
   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);
@@ skipping 15 matching lines @@
     // Recursive add bookmarks in sub-folders.
     if ((*i)->type == TYPE_FOLDER)
       GetWholeBookmarkFolder(db, list, list->size() - 1, &(*i)->empty_folder);
   }
 }
 
 void FirefoxImporter::LoadFavicons(
     sql::Connection* db,
     const FaviconMap& favicon_map,
     std::vector<ImportedFaviconUsage>* favicons) {
-  const char* query = "SELECT url, data FROM moz_favicons WHERE id=?";
+  const char query[] = "SELECT url, data FROM moz_favicons WHERE id=?";
   sql::Statement s(db->GetUniqueStatement(query));
 
   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()) {
       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(true);
   }
 }