Add base:: qualification to some CommandLine references in content.

content/browser/appcache/appcache_database.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 "content/browser/appcache/appcache_database.h"
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 159 matching lines @@
   else
     sql += "CREATE INDEX ";
   sql += info.index_name;
   sql += " ON ";
   sql += info.table_name;
   sql += info.columns;
   return db->Execute(sql.c_str());
 }
 
 std::string GetActiveExperimentFlags() {
-  if (CommandLine::ForCurrentProcess()->HasSwitch(kEnableExecutableHandlers))
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          kEnableExecutableHandlers))
     return std::string("executableHandlersEnabled");
   return std::string();
 }
 
 }  // anon namespace
 
 // AppCacheDatabase ----------------------------------------------------------
 
 AppCacheDatabase::GroupRecord::GroupRecord()
     : group_id(0) {
@@ skipping 514 matching lines @@
   const char* kSql =
       "INSERT INTO Namespaces"
       "  (cache_id, origin, type, namespace_url, target_url, is_pattern)"
       "  VALUES (?, ?, ?, ?, ?, ?)";
 
   // Note: quick and dirty storage for the 'executable' bit w/o changing
   // schemas, we use the high bit of 'type' field.
   int type_with_executable_bit = record->namespace_.type;
   if (record->namespace_.is_executable) {
     type_with_executable_bit |= 0x8000000;
-    DCHECK(CommandLine::ForCurrentProcess()->HasSwitch(
+    DCHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(
         kEnableExecutableHandlers));
   }
 
   sql::Statement statement(db_->GetCachedStatement(SQL_FROM_HERE, kSql));
   statement.BindInt64(0, record->cache_id);
   statement.BindString(1, record->origin.spec());
   statement.BindInt(2, type_with_executable_bit);
   statement.BindString(3, record->namespace_.namespace_url.spec());
   statement.BindString(4, record->namespace_.target_url.spec());
   statement.BindBool(5, record->namespace_.is_pattern);
@@ skipping 243 matching lines @@
   record->namespace_.target_url = GURL(statement->ColumnString(4));
   record->namespace_.is_pattern = statement->ColumnBool(5);
 
   // Note: quick and dirty storage for the 'executable' bit w/o changing
   // schemas, we use the high bit of 'type' field.
   record->namespace_.type = static_cast<AppCacheNamespaceType>
       (type_with_executable_bit & 0x7ffffff);
   record->namespace_.is_executable =
       (type_with_executable_bit & 0x80000000) != 0;
   DCHECK(!record->namespace_.is_executable ||
-      CommandLine::ForCurrentProcess()->HasSwitch(kEnableExecutableHandlers));
+      base::CommandLine::ForCurrentProcess()->HasSwitch(
+          kEnableExecutableHandlers));
 }
 
 void AppCacheDatabase::ReadOnlineWhiteListRecord(
     const sql::Statement& statement, OnlineWhiteListRecord* record) {
   record->cache_id = statement.ColumnInt64(0);
   record->namespace_url = GURL(statement.ColumnString(1));
   record->is_pattern = statement.ColumnBool(2);
 }
 
 bool AppCacheDatabase::LazyOpen(bool create_if_needed) {
@@ skipping 227 matching lines @@
 }
 
 void AppCacheDatabase::OnDatabaseError(int err, sql::Statement* stmt) {
   was_corruption_detected_ |= sql::IsErrorCatastrophic(err);
   if (!db_->ShouldIgnoreSqliteError(err))
     DLOG(ERROR) << db_->GetErrorMessage();
   // TODO: Maybe use non-catostrophic errors to trigger a full integrity check?
 }
 
 }  // namespace content