Pass Physical Web metadata through a struct

chrome/browser/android/physical_web/physical_web_data_source_android_unittest.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/physical_web/physical_web_data_source_android.h"
+
+#include "base/android/jni_android.h"
+#include "base/android/jni_string.h"
+#include "base/memory/ptr_util.h"
+#include "base/values.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using base::android::JavaParamRef;
+
+namespace {
+
+const char kRequestUrl[] = "https://awesomesite.us/";
+const double kDistanceEstimate = 42.0;
+const int64_t kScanTimestamp = 10000000L;  // 10M
+const char kSiteUrl[] = "https://awesomesite.us/page.html";
+const char kIconUrl[] = "https://awesomesite.us/favicon.ico";
+const char kTitle[] = "AwesomeSite";
+const char kDescription[] = "An awesome site";
+const char kGroupId[] = "14a8ef122";
+
+}  // namespace
+
+class PhysicalWebCollectionTest : public testing::Test {
+ public:
+  PhysicalWebCollectionTest() {}
+  ~PhysicalWebCollectionTest() override {}
+
+  void SetUp() override;
+  void TearDown() override;
+
+  PhysicalWebCollection* collection();
+  JNIEnv* env();
+  jstring javaString(const std::string& value);
+
+ private:
+  std::unique_ptr<PhysicalWebCollection> collection_;
+  JNIEnv* env_;
+};
+
+void PhysicalWebCollectionTest::SetUp() {
+  collection_ = base::MakeUnique<PhysicalWebCollection>();
+  env_ = base::android::AttachCurrentThread();
+}
+
+void PhysicalWebCollectionTest::TearDown() {
+  collection_.reset();
+}
+
+PhysicalWebCollection* PhysicalWebCollectionTest::collection() {
+  DCHECK(collection_);
+  return collection_.get();
+}
+
+JNIEnv* PhysicalWebCollectionTest::env() {
+  return env_;
+}
+
+jstring PhysicalWebCollectionTest::javaString(const std::string& value) {
+  return base::android::ConvertUTF8ToJavaString(env(), value).Release();
+}
+
+TEST_F(PhysicalWebCollectionTest, AppendMetadataItem_ListWork) {
+  collection()->AppendMetadataItem(
+      env(),
+      JavaParamRef<jobject>(NULL),
+      JavaParamRef<jstring>(env(), javaString(kRequestUrl)),
+      static_cast<jdouble>(kDistanceEstimate),
+      static_cast<jlong>(kScanTimestamp),
+      JavaParamRef<jstring>(env(), javaString(kSiteUrl)),
+      JavaParamRef<jstring>(env(), javaString(kIconUrl)),
+      JavaParamRef<jstring>(env(), javaString(kTitle)),
+      JavaParamRef<jstring>(env(), javaString(kDescription)),
+      JavaParamRef<jstring>(env(), javaString(kGroupId)));
+
+  std::unique_ptr<physical_web::MetadataList> metadata_list =
+      collection()->GetMetadataList();
+  EXPECT_EQ(1U, metadata_list->size());
+  auto metadata = (*metadata_list.get())[0];
+  EXPECT_EQ(kRequestUrl, metadata.scanned_url.spec());
+  EXPECT_EQ(kDistanceEstimate, metadata.distance_estimate);
+  EXPECT_EQ(kScanTimestamp, metadata.scan_timestamp.ToJavaTime());
+  EXPECT_EQ(kSiteUrl, metadata.resolved_url.spec());
+  EXPECT_EQ(kIconUrl, metadata.icon_url.spec());
+  EXPECT_EQ(kTitle, metadata.title);
+  EXPECT_EQ(kDescription, metadata.description);
+  EXPECT_EQ(kGroupId, metadata.group_id);
+}
+
+TEST_F(PhysicalWebCollectionTest, AppendMetadataItem_DictionaryValueWorks) {
+  collection()->AppendMetadataItem(
+      env(),
+      JavaParamRef<jobject>(NULL),
+      JavaParamRef<jstring>(env(), javaString(kRequestUrl)),
+      (jdouble) kDistanceEstimate,
+      (jlong) kScanTimestamp,

[mattreynolds, 2016/12/16 21:17:07]

some more here

+      JavaParamRef<jstring>(env(), javaString(kSiteUrl)),
+      JavaParamRef<jstring>(env(), javaString(kIconUrl)),
+      JavaParamRef<jstring>(env(), javaString(kTitle)),
+      JavaParamRef<jstring>(env(), javaString(kDescription)),
+      JavaParamRef<jstring>(env(), javaString(kGroupId)));
+
+  std::unique_ptr<base::ListValue> list_value =
+      collection()->GetMetadata();
+  EXPECT_EQ(1U, list_value->GetSize());
+  const base::Value* value;
+  EXPECT_TRUE(list_value->Get(0, &value));
+  const base::DictionaryValue* dictionary_value;
+  EXPECT_TRUE(value->GetAsDictionary(&dictionary_value));
+  std::string stored_scanned_url;
+  EXPECT_TRUE(dictionary_value->GetString(physical_web::kScannedUrlKey,
+                                          &stored_scanned_url));
+  EXPECT_EQ(kRequestUrl, stored_scanned_url);
+  double stored_distance_estimate;
+  EXPECT_TRUE(dictionary_value->GetDouble(physical_web::kDistanceEstimateKey,
+                                          &stored_distance_estimate));
+  EXPECT_EQ(kDistanceEstimate, stored_distance_estimate);
+  std::string stored_resolved_url;
+  EXPECT_TRUE(dictionary_value->GetString(physical_web::kResolvedUrlKey,
+                                          &stored_resolved_url));
+  EXPECT_EQ(kSiteUrl, stored_resolved_url);
+  std::string stored_icon_url;
+  EXPECT_TRUE(dictionary_value->GetString(physical_web::kIconUrlKey,
+                                          &stored_icon_url));
+  EXPECT_EQ(kIconUrl, stored_icon_url);
+  std::string stored_title;
+  EXPECT_TRUE(dictionary_value->GetString(physical_web::kTitleKey,
+                                          &stored_title));
+  EXPECT_EQ(kTitle, stored_title);
+  std::string stored_description;
+  EXPECT_TRUE(dictionary_value->GetString(physical_web::kDescriptionKey,
+                                          &stored_description));
+  EXPECT_EQ(kDescription, stored_description);
+  std::string stored_group_id;
+  EXPECT_TRUE(dictionary_value->GetString(physical_web::kGroupIdKey,
+                                          &stored_group_id));
+  EXPECT_EQ(kGroupId, stored_group_id);
+}