Convert string16 to base::string16 in content.

content/browser/indexed_db/indexed_db_database.h

 // Copyright (c) 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.
 
 #ifndef CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_DATABASE_H_
 #define CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_DATABASE_H_
 
 #include <list>
 #include <map>
 #include <string>
@@ skipping 34 matching lines @@
   };
 
   typedef std::vector<IndexedDBKey> IndexKeys;
   // Identifier is pair of (origin url, database name).
   typedef std::pair<GURL, base::string16> Identifier;
 
   static const int64 kInvalidId = 0;
   static const int64 kMinimumIndexId = 30;
 
   static scoped_refptr<IndexedDBDatabase> Create(
-      const string16& name,
+      const base::string16& name,
       IndexedDBBackingStore* backing_store,
       IndexedDBFactory* factory,
       const Identifier& unique_identifier);
 
   const Identifier& identifier() const { return identifier_; }
   IndexedDBBackingStore* backing_store() { return backing_store_.get(); }
 
   int64 id() const { return metadata_.id; }
   const base::string16& name() const { return metadata_.name; }
 
@@ skipping 15 matching lines @@
       scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
       int64 transaction_id,
       int64 version,
       blink::WebIDBDataLoss data_loss,
       std::string data_loss_message);
   void DeleteDatabase(scoped_refptr<IndexedDBCallbacks> callbacks);
   const IndexedDBDatabaseMetadata& metadata() const { return metadata_; }
 
   void CreateObjectStore(int64 transaction_id,
                          int64 object_store_id,
-                         const string16& name,
+                         const base::string16& name,
                          const IndexedDBKeyPath& key_path,
                          bool auto_increment);
   void DeleteObjectStore(int64 transaction_id, int64 object_store_id);
   void CreateTransaction(int64 transaction_id,
                          IndexedDBConnection* connection,
                          const std::vector<int64>& object_store_ids,
                          uint16 mode);
   void Close(IndexedDBConnection* connection, bool forced);
 
   void Commit(int64 transaction_id);
   void Abort(int64 transaction_id);
   void Abort(int64 transaction_id, const IndexedDBDatabaseError& error);
 
   void CreateIndex(int64 transaction_id,
                    int64 object_store_id,
                    int64 index_id,
-                   const string16& name,
+                   const base::string16& name,
                    const IndexedDBKeyPath& key_path,
                    bool unique,
                    bool multi_entry);
   void DeleteIndex(int64 transaction_id, int64 object_store_id, int64 index_id);
 
   IndexedDBTransactionCoordinator& transaction_coordinator() {
     return transaction_coordinator_;
   }
   const IndexedDBTransactionCoordinator& transaction_coordinator() const {
     return transaction_coordinator_;
@@ skipping 72 matching lines @@
       IndexedDBTransaction* transaction);
   void DeleteObjectStoreAbortOperation(
       const IndexedDBObjectStoreMetadata& object_store_metadata,
       IndexedDBTransaction* transaction);
   void VersionChangeOperation(int64 version,
                               scoped_refptr<IndexedDBCallbacks> callbacks,
                               scoped_ptr<IndexedDBConnection> connection,
                               blink::WebIDBDataLoss data_loss,
                               std::string data_loss_message,
                               IndexedDBTransaction* transaction);
-  void VersionChangeAbortOperation(const string16& previous_version,
+  void VersionChangeAbortOperation(const base::string16& previous_version,
                                    int64 previous_int_version,
                                    IndexedDBTransaction* transaction);
   void CreateIndexOperation(int64 object_store_id,
                             const IndexedDBIndexMetadata& index_metadata,
                             IndexedDBTransaction* transaction);
   void DeleteIndexOperation(int64 object_store_id,
                             const IndexedDBIndexMetadata& index_metadata,
                             IndexedDBTransaction* transaction);
   void CreateIndexAbortOperation(int64 object_store_id,
                                  int64 index_id,
@@ skipping 24 matching lines @@
                             scoped_ptr<IndexedDBKeyRange> key_range,
                             scoped_refptr<IndexedDBCallbacks> callbacks,
                             IndexedDBTransaction* transaction);
   void ClearOperation(int64 object_store_id,
                       scoped_refptr<IndexedDBCallbacks> callbacks,
                       IndexedDBTransaction* transaction);
 
  private:
   friend class base::RefCounted<IndexedDBDatabase>;
 
-  IndexedDBDatabase(const string16& name,
+  IndexedDBDatabase(const base::string16& name,
                     IndexedDBBackingStore* backing_store,
                     IndexedDBFactory* factory,
                     const Identifier& unique_identifier);
   ~IndexedDBDatabase();
 
   bool IsOpenConnectionBlocked() const;
   bool OpenInternal();
   void RunVersionChangeTransaction(scoped_refptr<IndexedDBCallbacks> callbacks,
                                    scoped_ptr<IndexedDBConnection> connection,
                                    int64 transaction_id,
@@ skipping 54 matching lines @@
   typedef std::list<PendingDeleteCall*> PendingDeleteCallList;
   PendingDeleteCallList pending_delete_calls_;
 
   typedef list_set<IndexedDBConnection*> ConnectionSet;
   ConnectionSet connections_;
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_INDEXED_DB_INDEXED_DB_DATABASE_H_