Cleanup: Better constify some strings in chrome/browser/{chromeos,extensions}.

chrome/browser/extensions/api/downloads/downloads_api.cc

 // Copyright (c) 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 "chrome/browser/extensions/api/downloads/downloads_api.h"
 
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 149 matching lines @@
 const char kStateInterrupted[] = "interrupted";
 const char kStateKey[] = "state";
 const char kTotalBytesGreaterKey[] = "totalBytesGreater";
 const char kTotalBytesKey[] = "totalBytes";
 const char kTotalBytesLessKey[] = "totalBytesLess";
 const char kUrlKey[] = "url";
 const char kUrlRegexKey[] = "urlRegex";
 
 // Note: Any change to the danger type strings, should be accompanied by a
 // corresponding change to downloads.json.
-const char* kDangerStrings[] = {
+const char* const kDangerStrings[] = {
   kDangerSafe,
   kDangerFile,
   kDangerUrl,
   kDangerContent,
   kDangerSafe,
   kDangerUncommon,
   kDangerAccepted,
   kDangerHost,
   kDangerUnwanted
 };
 COMPILE_ASSERT(arraysize(kDangerStrings) == content::DOWNLOAD_DANGER_TYPE_MAX,
                download_danger_type_enum_changed);
 
 // Note: Any change to the state strings, should be accompanied by a
 // corresponding change to downloads.json.
-const char* kStateStrings[] = {
+const char* const kStateStrings[] = {
   kStateInProgress,
   kStateComplete,
   kStateInterrupted,
   kStateInterrupted,
 };
 COMPILE_ASSERT(arraysize(kStateStrings) == DownloadItem::MAX_DOWNLOAD_STATE,
                download_item_state_enum_changed);
 
 const char* DangerString(content::DownloadDangerType danger) {
   DCHECK(danger >= 0);
@@ skipping 143 matching lines @@
     case 16: return IconLoader::SMALL;
     case 32: return IconLoader::NORMAL;
     default:
       NOTREACHED();
       return IconLoader::NORMAL;
   }
 }
 
 typedef base::hash_map<std::string, DownloadQuery::FilterType> FilterTypeMap;
 
-void InitFilterTypeMap(FilterTypeMap& filter_types) {
+void InitFilterTypeMap(FilterTypeMap* filter_types_ptr) {
+  FilterTypeMap& filter_types = *filter_types_ptr;
   filter_types[kBytesReceivedKey] = DownloadQuery::FILTER_BYTES_RECEIVED;
   filter_types[kExistsKey] = DownloadQuery::FILTER_EXISTS;
   filter_types[kFilenameKey] = DownloadQuery::FILTER_FILENAME;
   filter_types[kFilenameRegexKey] = DownloadQuery::FILTER_FILENAME_REGEX;
   filter_types[kMimeKey] = DownloadQuery::FILTER_MIME;
   filter_types[kPausedKey] = DownloadQuery::FILTER_PAUSED;
   filter_types[kQueryKey] = DownloadQuery::FILTER_QUERY;
   filter_types[kEndedAfterKey] = DownloadQuery::FILTER_ENDED_AFTER;
   filter_types[kEndedBeforeKey] = DownloadQuery::FILTER_ENDED_BEFORE;
   filter_types[kEndTimeKey] = DownloadQuery::FILTER_END_TIME;
   filter_types[kStartedAfterKey] = DownloadQuery::FILTER_STARTED_AFTER;
   filter_types[kStartedBeforeKey] = DownloadQuery::FILTER_STARTED_BEFORE;
   filter_types[kStartTimeKey] = DownloadQuery::FILTER_START_TIME;
   filter_types[kTotalBytesKey] = DownloadQuery::FILTER_TOTAL_BYTES;
   filter_types[kTotalBytesGreaterKey] =
     DownloadQuery::FILTER_TOTAL_BYTES_GREATER;
   filter_types[kTotalBytesLessKey] = DownloadQuery::FILTER_TOTAL_BYTES_LESS;
   filter_types[kUrlKey] = DownloadQuery::FILTER_URL;
   filter_types[kUrlRegexKey] = DownloadQuery::FILTER_URL_REGEX;
 }
 
 typedef base::hash_map<std::string, DownloadQuery::SortType> SortTypeMap;
 
-void InitSortTypeMap(SortTypeMap& sorter_types) {
+void InitSortTypeMap(SortTypeMap* sorter_types_ptr) {
+  SortTypeMap& sorter_types = *sorter_types_ptr;
   sorter_types[kBytesReceivedKey] = DownloadQuery::SORT_BYTES_RECEIVED;
   sorter_types[kDangerKey] = DownloadQuery::SORT_DANGER;
   sorter_types[kEndTimeKey] = DownloadQuery::SORT_END_TIME;
   sorter_types[kExistsKey] = DownloadQuery::SORT_EXISTS;
   sorter_types[kFilenameKey] = DownloadQuery::SORT_FILENAME;
   sorter_types[kMimeKey] = DownloadQuery::SORT_MIME;
   sorter_types[kPausedKey] = DownloadQuery::SORT_PAUSED;
   sorter_types[kStartTimeKey] = DownloadQuery::SORT_START_TIME;
   sorter_types[kStateKey] = DownloadQuery::SORT_STATE;
   sorter_types[kTotalBytesKey] = DownloadQuery::SORT_TOTAL_BYTES;
@@ skipping 62 matching lines @@
 }
 
 void CompileDownloadQueryOrderBy(
     const std::vector<std::string>& order_by_strs,
     std::string* error,
     DownloadQuery* query) {
   // TODO(benjhayden): Consider switching from LazyInstance to explicit string
   // comparisons.
   static base::LazyInstance<SortTypeMap> sorter_types =
     LAZY_INSTANCE_INITIALIZER;
-  if (sorter_types.Get().size() == 0)
-    InitSortTypeMap(sorter_types.Get());
+  if (sorter_types.Get().empty())
+    InitSortTypeMap(sorter_types.Pointer());
 
   for (std::vector<std::string>::const_iterator iter = order_by_strs.begin();
        iter != order_by_strs.end(); ++iter) {
     std::string term_str = *iter;
     if (term_str.empty())
       continue;
     DownloadQuery::SortDirection direction = DownloadQuery::ASCENDING;
     if (term_str[0] == '-') {
       direction = DownloadQuery::DESCENDING;
       term_str = term_str.substr(1);
@@ skipping 11 matching lines @@
 void RunDownloadQuery(
     const downloads::DownloadQuery& query_in,
     DownloadManager* manager,
     DownloadManager* incognito_manager,
     std::string* error,
     DownloadQuery::DownloadVector* results) {
   // TODO(benjhayden): Consider switching from LazyInstance to explicit string
   // comparisons.
   static base::LazyInstance<FilterTypeMap> filter_types =
     LAZY_INSTANCE_INITIALIZER;
-  if (filter_types.Get().size() == 0)
-    InitFilterTypeMap(filter_types.Get());
+  if (filter_types.Get().empty())
+    InitFilterTypeMap(filter_types.Pointer());
 
   DownloadQuery query_out;
 
   size_t limit = 1000;
   if (query_in.limit.get()) {
     if (*query_in.limit.get() < 0) {
       *error = errors::kInvalidQueryLimit;
       return;
     }
     limit = *query_in.limit.get();
@@ skipping 1428 matching lines @@
     const Extension* extension,
     UnloadedExtensionInfo::Reason reason) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   std::set<const Extension*>::iterator iter =
       shelf_disabling_extensions_.find(extension);
   if (iter != shelf_disabling_extensions_.end())
     shelf_disabling_extensions_.erase(iter);
 }
 
 }  // namespace extensions