Send microsecond resolution timestamps to Java history page so they can be sent back.

chrome/browser/android/history/browsing_history_bridge.cc

 // Copyright 2016 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/history/browsing_history_bridge.h"
 
 #include <jni.h>
 
+#include <utility>
+
 #include "base/android/jni_android.h"
 #include "base/android/jni_array.h"
 #include "base/android/jni_string.h"
 #include "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "chrome/browser/profiles/profile_android.h"
 #include "components/url_formatter/url_formatter.h"
 #include "jni/BrowsingHistoryBridge_jni.h"
 
@@ skipping 35 matching lines @@
       base::android::ConvertJavaStringToUTF16(env, j_query), options);
 }
 
 // BrowsingHistoryServiceHandler implementation
 void BrowsingHistoryBridge::OnQueryComplete(
     std::vector<BrowsingHistoryService::HistoryEntry>* results,
     BrowsingHistoryService::QueryResultsInfo* query_results_info) {
 
   JNIEnv* env = base::android::AttachCurrentThread();
 
-  for (auto it = results->begin(); it != results->end(); ++it) {
-
+  for (const BrowsingHistoryService::HistoryEntry& entry : *results) {
     // TODO(twellington): move the domain logic to BrowsingHistoryServce so it
     // can be shared with BrowsingHistoryHandler.
-    base::string16 domain = url_formatter::IDNToUnicode(it->url.host());
+    base::string16 domain = url_formatter::IDNToUnicode(entry.url.host());
     // When the domain is empty, use the scheme instead. This allows for a
     // sensible treatment of e.g. file: URLs when group by domain is on.
     if (domain.empty())
-      domain = base::UTF8ToUTF16(it->url.scheme() + ":");
+      domain = base::UTF8ToUTF16(entry.url.scheme() + ":");
 
-    std::vector<int64_t> timestamps;
-    for (auto timestampIt = it->all_timestamps.begin();
-         timestampIt != it->all_timestamps.end(); ++timestampIt) {
-      timestamps.push_back(
-          base::Time::FromInternalValue(*timestampIt).ToJavaTime());
+    std::vector<int64_t> java_timestamps;
+    std::vector<int64_t> native_timestamps;
+    for (int64_t timestamp : entry.all_timestamps) {
+      java_timestamps.push_back(
+          base::Time::FromInternalValue(timestamp).ToJavaTime());
+      native_timestamps.push_back(timestamp);
     }
 
     Java_BrowsingHistoryBridge_createHistoryItemAndAddToList(
         env, j_query_result_obj_.obj(),
-        base::android::ConvertUTF8ToJavaString(env, it->url.spec()),
+        base::android::ConvertUTF8ToJavaString(env, entry.url.spec()),
         base::android::ConvertUTF16ToJavaString(env, domain),
-        base::android::ConvertUTF16ToJavaString(env, it->title),
-        base::android::ToJavaLongArray(env, timestamps),
-        it->blocked_visit);
-
-    timestamps.clear();
+        base::android::ConvertUTF16ToJavaString(env, entry.title),
+        base::android::ToJavaLongArray(env, java_timestamps),
+        base::android::ToJavaLongArray(env, native_timestamps),
+        entry.blocked_visit);
   }
 
   Java_BrowsingHistoryBridge_onQueryHistoryComplete(
       env,
       j_history_service_obj_.obj(),
       j_query_result_obj_.obj(),
       !(query_results_info->reached_beginning));
 }
 
 void BrowsingHistoryBridge::MarkItemForRemoval(
     JNIEnv* env,
     const JavaParamRef<jobject>& obj,
     jstring j_url,
-    const JavaParamRef<jlongArray>& j_timestamps) {
+    const JavaParamRef<jlongArray>& j_native_timestamps) {
   std::unique_ptr<BrowsingHistoryService::HistoryEntry> entry(
       new BrowsingHistoryService::HistoryEntry());
   entry->url = GURL(base::android::ConvertJavaStringToUTF16(env, j_url));
 
   std::vector<int64_t> timestamps;
-  base::android::JavaLongArrayToInt64Vector(env, j_timestamps.obj(),
+  base::android::JavaLongArrayToInt64Vector(env, j_native_timestamps.obj(),
                                             &timestamps);
-  for (auto it = timestamps.begin(); it != timestamps.end(); ++it) {
-    base::Time visit_time = base::Time::FromJavaTime(*it);
-    entry->all_timestamps.insert(visit_time.ToInternalValue());
-  }
+  entry->all_timestamps.insert(timestamps.begin(), timestamps.end());
 
   items_to_remove_.push_back(std::move(entry));
-  timestamps.clear();

[Theresa, 2017/06/12 18:23:21]

I had added this to make sure int64 timestamps in the vector didn't hang around
in memory unnecessarily, but perhaps the call isn't really doing anything?

[skym, 2017/06/12 19:45:13]

Yeah, I don't think it was needed. The vector |timestamps| is going to be
destroyed as soon as we leave the current scope, which is the '}' below. I don't
really know what it does in its destructor, but I don't think that's something
we need to worry about.

 }
 
 void BrowsingHistoryBridge::RemoveItems(JNIEnv* env,
                                         const JavaParamRef<jobject>& obj) {
   browsing_history_service_->RemoveVisits(&items_to_remove_);
   items_to_remove_.clear();
 }
 
 void BrowsingHistoryBridge::OnRemoveVisitsComplete() {
   JNIEnv* env = base::android::AttachCurrentThread();
@@ skipping 23 matching lines @@
   return RegisterNativesImpl(env);
 }
 
 static jlong Init(JNIEnv* env,
                   const JavaParamRef<jobject>& obj,
                   const JavaParamRef<jobject>& j_profile) {
   BrowsingHistoryBridge* bridge =
       new BrowsingHistoryBridge(env, obj, j_profile);
   return reinterpret_cast<intptr_t>(bridge);
 }