Switch to standard integer types in chrome/browser/, part 1 of 4.

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 <stdint.h>
+
 #include <cmath>
 #include <list>
 #include <utility>
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "base/time/time.h"
 #include "chrome/browser/android/provider/blocking_ui_thread_async_request.h"
 #include "chrome/browser/android/provider/bookmark_model_observer_task.h"
 #include "chrome/browser/android/provider/run_on_ui_thread_blocking.h"
 #include "chrome/browser/bookmarks/bookmark_model_factory.h"
 #include "chrome/browser/bookmarks/managed_bookmark_service_factory.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 64 matching lines @@
 //
 // - HistoryProviderTask: base class for asynchronous requests that make use of
 //   AndroidHistoryProviderService. See AsyncServiceRequest for mode details.
 //
 // - SearchTermTask: base class for asynchronous requests that involve the
 //   search term API. Works in the same way as HistoryProviderTask.
 
 namespace {
 
 const char kDefaultUrlScheme[] = "http://";
-const int64 kInvalidContentProviderId = 0;
-const int64 kInvalidBookmarkId = -1;
+const int64_t kInvalidContentProviderId = 0;
+const int64_t kInvalidBookmarkId = -1;
 
 // ------------- Java-related utility methods ------------- //
 
 // Convert a BookmarkNode, |node|, to the java representation of a bookmark node
 // stored in |*jnode|. Parent node information is optional.
 void ConvertBookmarkNode(
     const BookmarkNode* node,
     const JavaRef<jobject>& parent_node,
     ScopedJavaGlobalRef<jobject>* jnode) {
   DCHECK(jnode);
@@ skipping 23 matching lines @@
 jboolean ConvertJBooleanObjectToPrimitive(JNIEnv* env, jobject boolean_object) {
   ScopedJavaLocalRef<jclass> jboolean_clazz =
       GetClass(env, "java/lang/Boolean");
   jmethodID boolean_value = MethodID::Get<MethodID::TYPE_INSTANCE>(
       env, jboolean_clazz.obj(), "booleanValue", "()Z");
   return env->CallBooleanMethod(boolean_object, boolean_value, NULL);
 }
 
 base::Time ConvertJlongToTime(jlong value) {
   return base::Time::UnixEpoch() +
-      base::TimeDelta::FromMilliseconds((int64)value);
+         base::TimeDelta::FromMilliseconds((int64_t)value);
 }
 
 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);
 }
 
@@ skipping 37 matching lines @@
   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 base::string16& title,
-            const base::string16& url,
-            const bool is_folder,
-            const int64 parent_id) {
-    int64 result = kInvalidBookmarkId;
+  int64_t Run(const base::string16& title,
+              const base::string16& url,
+              const bool is_folder,
+              const int64_t parent_id) {
+    int64_t result = kInvalidBookmarkId;
     RunOnUIThreadBlocking::Run(
         base::Bind(&AddBookmarkTask::RunOnUIThread,
                    model(), title, url, is_folder, parent_id, &result));
     return result;
   }
 
   static void RunOnUIThread(BookmarkModel* model,
                             const base::string16& title,
                             const base::string16& url,
                             const bool is_folder,
-                            const int64 parent_id,
-                            int64* result) {
+                            const int64_t parent_id,
+                            int64_t* result) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     DCHECK(result);
     GURL gurl = ParseAndMaybeAppendScheme(url, kDefaultUrlScheme);
 
     // Check if the bookmark already exists.
     const BookmarkNode* node = model->GetMostRecentlyAddedUserNodeForURL(gurl);
     if (!node) {
       const BookmarkNode* parent_node = NULL;
       if (parent_id >= 0)
         parent_node = bookmarks::GetBookmarkNodeByID(model, parent_id);
@@ skipping 15 matching lines @@
 
 // Utility method to remove a bookmark.
 class RemoveBookmarkTask : public BookmarkModelObserverTask {
  public:
   explicit RemoveBookmarkTask(BookmarkModel* model)
       : BookmarkModelObserverTask(model),
         deleted_(0),
         id_to_delete_(kInvalidBookmarkId) {}
   ~RemoveBookmarkTask() override {}
 
-  int Run(const int64 id) {
+  int Run(const int64_t id) {
     id_to_delete_ = id;
     RunOnUIThreadBlocking::Run(
         base::Bind(&RemoveBookmarkTask::RunOnUIThread, model(), id));
     return deleted_;
   }
 
-  static void RunOnUIThread(BookmarkModel* model, const int64 id) {
+  static void RunOnUIThread(BookmarkModel* model, const int64_t id) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     const BookmarkNode* node = bookmarks::GetBookmarkNodeByID(model, id);
     if (node && node->parent())
       model->Remove(node);
   }
 
   // Verify that the bookmark was actually removed. Called synchronously.
   void BookmarkNodeRemoved(BookmarkModel* bookmark_model,
                            const BookmarkNode* parent,
                            int old_index,
                            const BookmarkNode* node,
                            const std::set<GURL>& removed_urls) override {
     if (bookmark_model == model() && node->id() == id_to_delete_)
         ++deleted_;
   }
 
  private:
   int deleted_;
-  int64 id_to_delete_;
+  int64_t id_to_delete_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoveBookmarkTask);
 };
 
 // Utility method to remove all bookmarks that the user can edit.
 class RemoveAllUserBookmarksTask : public BookmarkModelObserverTask {
  public:
   explicit RemoveAllUserBookmarksTask(BookmarkModel* model)
       : BookmarkModelObserverTask(model) {}
 
@@ skipping 17 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){}
   ~UpdateBookmarkTask() override {}
 
-  int Run(const int64 id,
+  int Run(const int64_t id,
           const base::string16& title,
           const base::string16& url,
-          const int64 parent_id) {
+          const int64_t 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 int64_t id,
                             const base::string16& title,
                             const base::string16& url,
-                            const int64 parent_id) {
+                            const int64_t parent_id) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     const BookmarkNode* node = bookmarks::GetBookmarkNodeByID(model, 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())
           model->SetURL(node, bookmark_url);
@@ skipping 12 matching lines @@
 
   // Verify that the bookmark was actually updated. Called synchronously.
   void BookmarkNodeChanged(BookmarkModel* bookmark_model,
                            const BookmarkNode* node) override {
     if (bookmark_model == model() && node->id() == id_to_update_)
       ++updated_;
   }
 
  private:
   int updated_;
-  int64 id_to_update_;
+  int64_t id_to_update_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdateBookmarkTask);
 };
 
 // Checks if a node exists in the bookmark model.
 class BookmarkNodeExistsTask : public BookmarkModelTask {
  public:
   explicit BookmarkNodeExistsTask(BookmarkModel* model)
       : BookmarkModelTask(model) {
   }
 
-  bool Run(const int64 id) {
+  bool Run(const int64_t id) {
     bool result = false;
     RunOnUIThreadBlocking::Run(
         base::Bind(&BookmarkNodeExistsTask::RunOnUIThread,
                    model(), id, &result));
     return result;
   }
 
   static void RunOnUIThread(BookmarkModel* model,
-                            const int64 id,
+                            const int64_t id,
                             bool* result) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     DCHECK(result);
     *result = bookmarks::GetBookmarkNodeByID(model, id) != NULL;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BookmarkNodeExistsTask);
 };
 
 // Checks if a node belongs to the Mobile Bookmarks hierarchy branch.
 class IsInMobileBookmarksBranchTask : public BookmarkModelTask {
  public:
   explicit IsInMobileBookmarksBranchTask(BookmarkModel* model)
       : BookmarkModelTask(model) {}
 
-  bool Run(const int64 id) {
+  bool Run(const int64_t id) {
     bool result = false;
     RunOnUIThreadBlocking::Run(
         base::Bind(&IsInMobileBookmarksBranchTask::RunOnUIThread,
                    model(), id, &result));
     return result;
   }
 
   static void RunOnUIThread(BookmarkModel* model,
-                            const int64 id,
-                            bool *result) {
+                            const int64_t id,
+                            bool* result) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     DCHECK(result);
     const BookmarkNode* node = bookmarks::GetBookmarkNodeByID(model, id);
     const BookmarkNode* mobile_node = model->mobile_node();
     while (node && node != mobile_node)
       node = node->parent();
 
     *result = node == mobile_node;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(IsInMobileBookmarksBranchTask);
 };
 
 // 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 base::string16& title, const int64 parent_id) {
-    int64 result = kInvalidBookmarkId;
+  int64_t Run(const base::string16& title, const int64_t parent_id) {
+    int64_t result = kInvalidBookmarkId;
     RunOnUIThreadBlocking::Run(
         base::Bind(&CreateBookmarksFolderOnceTask::RunOnUIThread,
                    model(), title, parent_id, &result));
     return result;
   }
 
   static void RunOnUIThread(BookmarkModel* model,
                             const base::string16& title,
-                            const int64 parent_id,
-                            int64* result) {
+                            const int64_t parent_id,
+                            int64_t* result) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     DCHECK(result);
 
     // Invalid ids are assumed to refer to the Mobile Bookmarks folder.
     const BookmarkNode* parent =
         parent_id >= 0 ? bookmarks::GetBookmarkNodeByID(model, parent_id)
                        : model->mobile_node();
     DCHECK(parent);
 
     bool in_mobile_bookmarks;
@@ skipping 82 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(GetEditableBookmarkFoldersTask);
 };
 
 // Creates a Java BookmarkNode object for a node given its id.
 class GetBookmarkNodeTask : public BookmarkModelTask {
  public:
   explicit GetBookmarkNodeTask(BookmarkModel* model)
       : BookmarkModelTask(model) {
   }
 
-  void Run(const int64 id,
+  void Run(const int64_t id,
            bool get_parent,
            bool get_children,
            ScopedJavaGlobalRef<jobject>* jnode) {
     return RunOnUIThreadBlocking::Run(
         base::Bind(&GetBookmarkNodeTask::RunOnUIThread,
                    model(), id, get_parent, get_children, jnode));
   }
 
   static void RunOnUIThread(BookmarkModel* model,
-                            const int64 id,
+                            const int64_t id,
                             bool get_parent,
                             bool get_children,
                             ScopedJavaGlobalRef<jobject>* jnode) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
     const BookmarkNode* node = bookmarks::GetBookmarkNodeByID(model, id);
     if (!node || !jnode)
       return;
 
     ScopedJavaGlobalRef<jobject> jparent;
     if (get_parent) {
@@ skipping 536 matching lines @@
         ConvertJLongObjectToPrimitive(env, created)));
 
   if (isBookmark)
     row->set_is_bookmark(ConvertJBooleanObjectToPrimitive(env, isBookmark));
 
   if (date)
     row->set_last_visit_time(ConvertJlongToTime(ConvertJLongObjectToPrimitive(
         env, date)));
 
   if (favicon) {
-    std::vector<uint8> bytes;
+    std::vector<uint8_t> bytes;
     base::android::JavaByteArrayToByteVector(env, favicon, &bytes);
     row->set_favicon(base::RefCountedBytes::TakeVector(&bytes));
   }
 
   if (title)
     row->set_title(ConvertJavaStringToUTF16(env, title));
 
   if (visits)
     row->set_visit_count(ConvertJIntegerToJint(env, visits));
 
@@ skipping 538 matching lines @@
   ScopedJavaLocalRef<jobject> obj = weak_java_provider_.get(env);
   if (obj.is_null())
     return;
   Java_ChromeBrowserProvider_onSearchTermChanged(env, obj.obj());
 }
 
 void ChromeBrowserProvider::OnKeywordSearchTermDeleted(
     history::HistoryService* history_service,
     history::URLID url_id) {
 }