Replace string16 with base::string16.

chrome/browser/android/provider/chrome_browser_provider.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/android/provider/chrome_browser_provider.h"
 
 #include <list>
 #include <utility>
 
 #include "base/android/jni_android.h"
@@ skipping 129 matching lines @@
 }
 
 jint ConvertJIntegerToJint(JNIEnv* env, jobject integer_obj) {
   ScopedJavaLocalRef<jclass> jinteger_clazz =
       GetClass(env, "java/lang/Integer");
   jmethodID int_value = MethodID::Get<MethodID::TYPE_INSTANCE>(
       env, jinteger_clazz.obj(), "intValue", "()I");
   return env->CallIntMethod(integer_obj, int_value, NULL);
 }
 
-std::vector<string16> ConvertJStringArrayToString16Array(JNIEnv* env,
-                                                         jobjectArray array) {
-  std::vector<string16> results;
+std::vector<base::string16> ConvertJStringArrayToString16Array(
+    JNIEnv* env,
+    jobjectArray array) {
+  std::vector<base::string16> results;
   if (array) {
     jsize len = env->GetArrayLength(array);
     for (int i = 0; i < len; i++) {
       results.push_back(ConvertJavaStringToUTF16(env,
           static_cast<jstring>(env->GetObjectArrayElement(array, i))));
     }
   }
   return results;
 }
 
 // ------------- Utility methods used by tasks ------------- //
 
 // Parse the given url and return a GURL, appending the default scheme
 // if one is not present.
-GURL ParseAndMaybeAppendScheme(const string16& url,
+GURL ParseAndMaybeAppendScheme(const base::string16& url,
                                const char* default_scheme) {
   GURL gurl(url);
   if (!gurl.is_valid() && !gurl.has_scheme()) {
-    string16 refined_url(ASCIIToUTF16(default_scheme));
+    base::string16 refined_url(ASCIIToUTF16(default_scheme));
     refined_url.append(url);
     gurl = GURL(refined_url);
   }
   return gurl;
 }
 
 const BookmarkNode* GetChildFolderByTitle(const BookmarkNode* parent,
-                                          const string16& title) {
+                                          const base::string16& title) {
   for (int i = 0; i < parent->child_count(); ++i) {
     if (parent->GetChild(i)->is_folder() &&
         parent->GetChild(i)->GetTitle() == title) {
       return parent->GetChild(i);
     }
   }
   return NULL;
 }
 
 // ------------- Synchronous task classes ------------- //
 
 // Utility task to add a bookmark.
 class AddBookmarkTask : public BookmarkModelTask {
  public:
   explicit AddBookmarkTask(BookmarkModel* model) : BookmarkModelTask(model) {}
 
-  int64 Run(const string16& title,
-            const string16& url,
+  int64 Run(const base::string16& title,
+            const base::string16& url,
             const bool is_folder,
             const int64 parent_id) {
     int64 result = kInvalidBookmarkId;
     RunOnUIThreadBlocking::Run(
         base::Bind(&AddBookmarkTask::RunOnUIThread,
                    model(), title, url, is_folder, parent_id, &result));
     return result;
   }
 
   static void RunOnUIThread(BookmarkModel* model,
-                            const string16& title,
-                            const string16& url,
+                            const base::string16& title,
+                            const base::string16& url,
                             const bool is_folder,
                             const int64 parent_id,
                             int64* result) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     DCHECK(result);
     GURL gurl = ParseAndMaybeAppendScheme(url, kDefaultUrlScheme);
 
     // Check if the bookmark already exists.
     const BookmarkNode* node = model->GetMostRecentlyAddedNodeForURL(gurl);
     if (!node) {
@@ skipping 82 matching lines @@
 // Utility method to update a bookmark.
 class UpdateBookmarkTask : public BookmarkModelObserverTask {
  public:
   explicit UpdateBookmarkTask(BookmarkModel* model)
       : BookmarkModelObserverTask(model),
         updated_(0),
         id_to_update_(kInvalidBookmarkId){}
   virtual ~UpdateBookmarkTask() {}
 
   int Run(const int64 id,
-          const string16& title,
-          const string16& url,
+          const base::string16& title,
+          const base::string16& url,
           const int64 parent_id) {
     id_to_update_ = id;
     RunOnUIThreadBlocking::Run(
         base::Bind(&UpdateBookmarkTask::RunOnUIThread,
                    model(), id, title, url, parent_id));
     return updated_;
   }
 
   static void RunOnUIThread(BookmarkModel* model,
                             const int64 id,
-                            const string16& title,
-                            const string16& url,
+                            const base::string16& title,
+                            const base::string16& url,
                             const int64 parent_id) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     const BookmarkNode* node = model->GetNodeByID(id);
     if (node) {
       if (node->GetTitle() != title)
         model->SetTitle(node, title);
 
       if (node->type() == BookmarkNode::URL) {
         GURL bookmark_url = ParseAndMaybeAppendScheme(url, kDefaultUrlScheme);
         if (bookmark_url != node->url())
@@ skipping 83 matching lines @@
 };
 
 // Creates folder or retrieves its id if already exists.
 // An invalid parent id is assumed to represent the Mobile Bookmarks folder.
 // Can only be used to create folders inside the Mobile Bookmarks branch.
 class CreateBookmarksFolderOnceTask : public BookmarkModelTask {
  public:
   explicit CreateBookmarksFolderOnceTask(BookmarkModel* model)
       : BookmarkModelTask(model) {}
 
-  int64 Run(const string16& title, const int64 parent_id) {
+  int64 Run(const base::string16& title, const int64 parent_id) {
     int64 result = kInvalidBookmarkId;
     RunOnUIThreadBlocking::Run(
         base::Bind(&CreateBookmarksFolderOnceTask::RunOnUIThread,
                    model(), title, parent_id, &result));
     return result;
   }
 
   static void RunOnUIThread(BookmarkModel* model,
-                            const string16& title,
+                            const base::string16& title,
                             const int64 parent_id,
                             int64* result) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     DCHECK(result);
 
     // Invalid ids are assumed to refer to the Mobile Bookmarks folder.
     const BookmarkNode* parent = parent_id >= 0 ?
         model->GetNodeByID(parent_id) : model->mobile_node();
     DCHECK(parent);
 
     bool in_mobile_bookmarks;
     IsInMobileBookmarksBranchTask::RunOnUIThread(model, parent->id(),
                                                  &in_mobile_bookmarks);
     if (!in_mobile_bookmarks) {
       // The parent folder must be inside the Mobile Bookmarks folder.
       *result = kInvalidBookmarkId;
       return;
     }
 
     const BookmarkNode* node = GetChildFolderByTitle(parent, title);
     if (node) {
       *result = node->id();
       return;
     }
 
-    AddBookmarkTask::RunOnUIThread(model, title, string16(), true,
+    AddBookmarkTask::RunOnUIThread(model, title, base::string16(), true,
                                    parent->id(), result);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CreateBookmarksFolderOnceTask);
 };
 
 // Creates a Java BookmarkNode object for a node given its id.
 class GetAllBookmarkFoldersTask : public BookmarkModelTask {
  public:
@@ skipping 269 matching lines @@
 class QueryBookmarksFromAPITask : public HistoryProviderTask {
  public:
   QueryBookmarksFromAPITask(AndroidHistoryProviderService* service,
                             CancelableRequestConsumer* cancelable_consumer)
       : HistoryProviderTask(service, cancelable_consumer),
         result_(NULL) {}
 
   history::AndroidStatement* Run(
       const std::vector<history::HistoryAndBookmarkRow::ColumnID>& projections,
       const std::string& selection,
-      const std::vector<string16>& selection_args,
+      const std::vector<base::string16>& selection_args,
       const std::string& sort_order) {
     RunAsyncRequestOnUIThreadBlocking(
         base::Bind(&AndroidHistoryProviderService::QueryHistoryAndBookmarks,
                    base::Unretained(service()), projections, selection,
                    selection_args, sort_order, cancelable_consumer(),
                    base::Bind(&QueryBookmarksFromAPITask::OnBookmarksQueried,
                               base::Unretained(this))));
     return result_;
   }
 
@@ skipping 13 matching lines @@
 // Updates bookmarks from the API.
 class UpdateBookmarksFromAPITask : public HistoryProviderTask {
  public:
   UpdateBookmarksFromAPITask(AndroidHistoryProviderService* service,
                              CancelableRequestConsumer* cancelable_consumer)
       : HistoryProviderTask(service, cancelable_consumer),
         result_(0) {}
 
   int Run(const history::HistoryAndBookmarkRow& row,
           const std::string& selection,
-          const std::vector<string16>& selection_args) {
+          const std::vector<base::string16>& selection_args) {
     RunAsyncRequestOnUIThreadBlocking(
         base::Bind(&AndroidHistoryProviderService::UpdateHistoryAndBookmarks,
                    base::Unretained(service()), row, selection,
                    selection_args, cancelable_consumer(),
                    base::Bind(&UpdateBookmarksFromAPITask::OnBookmarksUpdated,
                               base::Unretained(this))));
     return result_;
   }
 
  private:
@@ skipping 11 matching lines @@
 
 // Removes bookmarks from the API.
 class RemoveBookmarksFromAPITask : public HistoryProviderTask {
  public:
   RemoveBookmarksFromAPITask(AndroidHistoryProviderService* service,
                              CancelableRequestConsumer* cancelable_consumer)
       : HistoryProviderTask(service, cancelable_consumer),
         result_(0) {}
 
   int Run(const std::string& selection,
-          const std::vector<string16>& selection_args) {
+          const std::vector<base::string16>& selection_args) {
     RunAsyncRequestOnUIThreadBlocking(
         base::Bind(&AndroidHistoryProviderService::DeleteHistoryAndBookmarks,
                    base::Unretained(service()), selection, selection_args,
                    cancelable_consumer(),
                    base::Bind(&RemoveBookmarksFromAPITask::OnBookmarksRemoved,
                               base::Unretained(this))));
     return result_;
   }
 
  private:
@@ skipping 11 matching lines @@
 
 // Removes history from the API.
 class RemoveHistoryFromAPITask : public HistoryProviderTask {
  public:
   RemoveHistoryFromAPITask(AndroidHistoryProviderService* service,
                            CancelableRequestConsumer* cancelable_consumer)
       : HistoryProviderTask(service, cancelable_consumer),
         result_(0) {}
 
   int Run(const std::string& selection,
-          const std::vector<string16>& selection_args) {
+          const std::vector<base::string16>& selection_args) {
     RunAsyncRequestOnUIThreadBlocking(
         base::Bind(&AndroidHistoryProviderService::DeleteHistory,
                    base::Unretained(service()), selection,
                    selection_args, cancelable_consumer(),
                    base::Bind(&RemoveHistoryFromAPITask::OnHistoryRemoved,
                               base::Unretained(this))));
     return result_;
   }
 
  private:
@@ skipping 91 matching lines @@
  public:
     QuerySearchTermsFromAPITask(AndroidHistoryProviderService* service,
                                 CancelableRequestConsumer* cancelable_consumer,
                                 Profile* profile)
         : SearchTermTask(service, cancelable_consumer, profile),
           result_(NULL) {}
 
   history::AndroidStatement* Run(
       const std::vector<history::SearchRow::ColumnID>& projections,
       const std::string& selection,
-      const std::vector<string16>& selection_args,
+      const std::vector<base::string16>& selection_args,
       const std::string& sort_order) {
     RunAsyncRequestOnUIThreadBlocking(
         base::Bind(&AndroidHistoryProviderService::QuerySearchTerms,
                    base::Unretained(service()), projections, selection,
                    selection_args, sort_order, cancelable_consumer(),
                    base::Bind(
                       &QuerySearchTermsFromAPITask::OnSearchTermsQueried,
                       base::Unretained(this))));
     return result_;
   }
@@ skipping 16 matching lines @@
 class UpdateSearchTermsFromAPITask : public SearchTermTask {
  public:
     UpdateSearchTermsFromAPITask(AndroidHistoryProviderService* service,
                                  CancelableRequestConsumer* cancelable_consumer,
                                  Profile* profile)
         : SearchTermTask(service, cancelable_consumer, profile),
           result_(0) {}
 
   int Run(const history::SearchRow& row,
           const std::string& selection,
-          const std::vector<string16>& selection_args) {
+          const std::vector<base::string16>& selection_args) {
     RunAsyncRequestOnUIThreadBlocking(
         base::Bind(&UpdateSearchTermsFromAPITask::MakeRequestOnUIThread,
                    base::Unretained(this), row, selection, selection_args));
     return result_;
   }
 
  private:
-  void MakeRequestOnUIThread(const history::SearchRow& row,
-                             const std::string& selection,
-                             const std::vector<string16>& selection_args) {
+  void MakeRequestOnUIThread(
+      const history::SearchRow& row,
+      const std::string& selection,
+      const std::vector<base::string16>& selection_args) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     history::SearchRow internal_row = row;
     BuildSearchRow(&internal_row);
     service()->UpdateSearchTerms(
         internal_row,
         selection,
         selection_args,
         cancelable_consumer(),
         base::Bind(&UpdateSearchTermsFromAPITask::OnSearchTermsUpdated,
                    base::Unretained(this)));
@@ skipping 14 matching lines @@
 
 // Removes search terms from the API.
 class RemoveSearchTermsFromAPITask : public SearchTermTask {
  public:
     RemoveSearchTermsFromAPITask(AndroidHistoryProviderService* service,
                                  CancelableRequestConsumer* cancelable_consumer,
                                  Profile* profile)
         : SearchTermTask(service, cancelable_consumer, profile), result_() {}
 
   int Run(const std::string& selection,
-          const std::vector<string16>& selection_args) {
+          const std::vector<base::string16>& selection_args) {
     RunAsyncRequestOnUIThreadBlocking(
         base::Bind(&AndroidHistoryProviderService::DeleteSearchTerms,
                    base::Unretained(service()), selection, selection_args,
                    cancelable_consumer(),
                    base::Bind(
                        &RemoveSearchTermsFromAPITask::OnSearchTermsDeleted,
                        base::Unretained(this))));
     return result_;
   }
 
@@ skipping 22 matching lines @@
                      jbyteArray favicon,
                      jstring title,
                      jobject visits,
                      jlong parent_id,
                      history::HistoryAndBookmarkRow* row,
                      BookmarkModel* model) {
   // Needed because of the internal bookmark model task invocation.
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (url) {
-    string16 raw_url = ConvertJavaStringToUTF16(env, url);
+    base::string16 raw_url = ConvertJavaStringToUTF16(env, url);
     // GURL doesn't accept the URL without protocol, but the Android CTS
     // allows it. We are trying to prefix with 'http://' to see whether
     // GURL thinks it is a valid URL. The original url will be stored in
     // history::BookmarkRow.raw_url_.
     GURL gurl = ParseAndMaybeAppendScheme(raw_url, kDefaultUrlScheme);
     row->set_url(gurl);
     row->set_raw_url(UTF16ToUTF8(raw_url));
   }
 
   if (created)
@@ skipping 87 matching lines @@
 }
 
 // ------------- Provider public APIs ------------- //
 
 jlong ChromeBrowserProvider::AddBookmark(JNIEnv* env,
                                          jobject,
                                          jstring jurl,
                                          jstring jtitle,
                                          jboolean is_folder,
                                          jlong parent_id) {
-  string16 url;
+  base::string16 url;
   if (jurl)
     url = ConvertJavaStringToUTF16(env, jurl);
-  string16 title = ConvertJavaStringToUTF16(env, jtitle);
+  base::string16 title = ConvertJavaStringToUTF16(env, jtitle);
 
   AddBookmarkTask task(bookmark_model_);
   return task.Run(title, url, is_folder, parent_id);
 }
 
 jint ChromeBrowserProvider::RemoveBookmark(JNIEnv*, jobject, jlong id) {
   RemoveBookmarkTask task(bookmark_model_);
   return task.Run(id);
 }
 
 jint ChromeBrowserProvider::UpdateBookmark(JNIEnv* env,
                                            jobject,
                                            jlong id,
                                            jstring jurl,
                                            jstring jtitle,
                                            jlong parent_id) {
-  string16 url;
+  base::string16 url;
   if (jurl)
     url = ConvertJavaStringToUTF16(env, jurl);
-  string16 title = ConvertJavaStringToUTF16(env, jtitle);
+  base::string16 title = ConvertJavaStringToUTF16(env, jtitle);
 
   UpdateBookmarkTask task(bookmark_model_);
   return task.Run(id, title, url, parent_id);
 }
 
 // Add the bookmark with the given column values.
 jlong ChromeBrowserProvider::AddBookmarkFromAPI(JNIEnv* env,
                                                 jobject obj,
                                                 jstring url,
                                                 jobject created,
@@ skipping 41 matching lines @@
       if (id == history::HistoryAndBookmarkRow::COLUMN_END) {
         // Ignore the unknown column; As Android platform will send us
         // the non public column.
         continue;
       }
       query_columns.push_back(id);
       columns_name.push_back(name);
     }
   }
 
-  std::vector<string16> where_args =
+  std::vector<base::string16> where_args =
       ConvertJStringArrayToString16Array(env, selection_args);
 
   std::string where_clause;
   if (selections) {
     where_clause = ConvertJavaStringToUTF8(env, selections);
   }
 
   std::string sort_clause;
   if (sort_order) {
     sort_clause = ConvertJavaStringToUTF8(env, sort_order);
@@ skipping 22 matching lines @@
                                                   jbyteArray favicon,
                                                   jstring title,
                                                   jobject visits,
                                                   jlong parent_id,
                                                   jstring selections,
                                                   jobjectArray selection_args) {
   history::HistoryAndBookmarkRow row;
   FillBookmarkRow(env, obj, url, created, isBookmark, date, favicon, title,
                   visits, parent_id, &row, bookmark_model_);
 
-  std::vector<string16> where_args =
+  std::vector<base::string16> where_args =
       ConvertJStringArrayToString16Array(env, selection_args);
 
   std::string where_clause;
   if (selections)
     where_clause = ConvertJavaStringToUTF8(env, selections);
 
   UpdateBookmarksFromAPITask task(service_.get(), &android_history_consumer_);
   return task.Run(row, where_clause, where_args);
 }
 
 jint ChromeBrowserProvider::RemoveBookmarkFromAPI(JNIEnv* env,
                                                   jobject obj,
                                                   jstring selections,
                                                   jobjectArray selection_args) {
-  std::vector<string16> where_args =
+  std::vector<base::string16> where_args =
       ConvertJStringArrayToString16Array(env, selection_args);
 
   std::string where_clause;
   if (selections)
     where_clause = ConvertJavaStringToUTF8(env, selections);
 
   RemoveBookmarksFromAPITask task(service_.get(), &android_history_consumer_);
   return task.Run(where_clause, where_args);
 }
 
 jint ChromeBrowserProvider::RemoveHistoryFromAPI(JNIEnv* env,
                                                  jobject obj,
                                                  jstring selections,
                                                  jobjectArray selection_args) {
-  std::vector<string16> where_args =
+  std::vector<base::string16> where_args =
       ConvertJStringArrayToString16Array(env, selection_args);
 
   std::string where_clause;
   if (selections)
     where_clause = ConvertJavaStringToUTF8(env, selections);
 
   RemoveHistoryFromAPITask task(service_.get(), &android_history_consumer_);
   return task.Run(where_clause, where_args);
 }
 
@@ skipping 40 matching lines @@
           history::SearchRow::GetColumnID(name);
       if (id == history::SearchRow::COLUMN_END) {
         LOG(ERROR) << "Can not find " << name;
         return ScopedJavaLocalRef<jobject>();
       }
       query_columns.push_back(id);
       columns_name.push_back(name);
     }
   }
 
-  std::vector<string16> where_args =
+  std::vector<base::string16> where_args =
       ConvertJStringArrayToString16Array(env, selection_args);
 
   std::string where_clause;
   if (selections) {
     where_clause = ConvertJavaStringToUTF8(env, selections);
   }
 
   std::string sort_clause;
   if (sort_order) {
     sort_clause = ConvertJavaStringToUTF8(env, sort_order);
@@ skipping 12 matching lines @@
 }
 
 // Updates the search terms with the given column values. The value is not
 // given if it is NULL.
 jint ChromeBrowserProvider::UpdateSearchTermFromAPI(
     JNIEnv* env, jobject obj, jstring search_term, jobject date,
     jstring selections, jobjectArray selection_args) {
   history::SearchRow row;
   FillSearchRow(env, obj, search_term, date, &row);
 
-  std::vector<string16> where_args = ConvertJStringArrayToString16Array(
+  std::vector<base::string16> where_args = ConvertJStringArrayToString16Array(
       env, selection_args);
 
   std::string where_clause;
   if (selections)
     where_clause = ConvertJavaStringToUTF8(env, selections);
 
   UpdateSearchTermsFromAPITask task(service_.get(), &android_history_consumer_,
                                     profile_);
   return task.Run(row, where_clause, where_args);
 }
 
 jint ChromeBrowserProvider::RemoveSearchTermFromAPI(
     JNIEnv* env, jobject obj, jstring selections, jobjectArray selection_args) {
-  std::vector<string16> where_args =
+  std::vector<base::string16> where_args =
       ConvertJStringArrayToString16Array(env, selection_args);
 
   std::string where_clause;
   if (selections)
     where_clause = ConvertJavaStringToUTF8(env, selections);
 
   RemoveSearchTermsFromAPITask task(service_.get(), &android_history_consumer_,
                                     profile_);
   return task.Run(where_clause, where_args);
 }
 
 // ------------- Provider custom APIs ------------- //
 
 jboolean ChromeBrowserProvider::BookmarkNodeExists(
     JNIEnv* env,
     jobject obj,
     jlong id) {
   BookmarkNodeExistsTask task(bookmark_model_);
   return task.Run(id);
 }
 
 jlong ChromeBrowserProvider::CreateBookmarksFolderOnce(
     JNIEnv* env,
     jobject obj,
     jstring jtitle,
     jlong parent_id) {
-  string16 title = ConvertJavaStringToUTF16(env, jtitle);
+  base::string16 title = ConvertJavaStringToUTF16(env, jtitle);
   if (title.empty())
     return kInvalidBookmarkId;
 
   CreateBookmarksFolderOnceTask task(bookmark_model_);
   return task.Run(title, parent_id);
 }
 
 ScopedJavaLocalRef<jobject> ChromeBrowserProvider::GetAllBookmarkFolders(
     JNIEnv* env,
     jobject obj) {
@@ skipping 110 matching lines @@
     Java_ChromeBrowserProvider_onBookmarkChanged(env, obj.obj());
   } else if (type ==
       chrome::NOTIFICATION_HISTORY_KEYWORD_SEARCH_TERM_UPDATED) {
     JNIEnv* env = AttachCurrentThread();
     ScopedJavaLocalRef<jobject> obj = weak_java_provider_.get(env);
     if (obj.is_null())
       return;
     Java_ChromeBrowserProvider_onSearchTermChanged(env, obj.obj());
   }
 }