sync/test/fake_server/android/fake_server_helper_android.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "sync/test/fake_server/android/fake_server_helper_android.h"
   6
   7 #include <jni.h>
   8
   9 #include "base/android/jni_string.h"
  10 #include "base/basictypes.h"
  11 #include "base/logging.h"
  12 #include "base/memory/scoped_ptr.h"
  13 #include "jni/FakeServerHelper_jni.h"
  14 #include "sync/internal_api/public/base/model_type.h"
  15 #include "sync/internal_api/public/network_resources.h"
  16 #include "sync/protocol/sync.pb.h"
  17 #include "sync/test/fake_server/bookmark_entity_builder.h"
  18 #include "sync/test/fake_server/entity_builder_factory.h"
  19 #include "sync/test/fake_server/fake_server.h"
  20 #include "sync/test/fake_server/fake_server_network_resources.h"
  21 #include "sync/test/fake_server/fake_server_verifier.h"
  22 #include "sync/test/fake_server/tombstone_entity.h"
  23 #include "sync/test/fake_server/unique_client_entity.h"
  24 #include "testing/gtest/include/gtest/gtest.h"
  25 #include "url/gurl.h"
  26
  27 FakeServerHelperAndroid::FakeServerHelperAndroid(JNIEnv* env, jobject obj) {
  28 }
  29
  30 FakeServerHelperAndroid::~FakeServerHelperAndroid() { }
  31
  32 static jlong Init(JNIEnv* env, jobject obj) {
  33   FakeServerHelperAndroid* fake_server_android =
  34       new FakeServerHelperAndroid(env, obj);
  35   return reinterpret_cast<intptr_t>(fake_server_android);
  36 }
  37
  38 jlong FakeServerHelperAndroid::CreateFakeServer(JNIEnv* env, jobject obj) {
  39   fake_server::FakeServer* fake_server = new fake_server::FakeServer();
  40   return reinterpret_cast<intptr_t>(fake_server);
  41 }
  42
  43 jlong FakeServerHelperAndroid::CreateNetworkResources(JNIEnv* env,
  44                                                       jobject obj,
  45                                                       jlong fake_server) {
  46   fake_server::FakeServer* fake_server_ptr =
  47       reinterpret_cast<fake_server::FakeServer*>(fake_server);
  48   syncer::NetworkResources* resources =
  49       new fake_server::FakeServerNetworkResources(fake_server_ptr->AsWeakPtr());
  50   return reinterpret_cast<intptr_t>(resources);
  51 }
  52
  53 void FakeServerHelperAndroid::DeleteFakeServer(JNIEnv* env,
  54                                                jobject obj,
  55                                                jlong fake_server) {
  56   fake_server::FakeServer* fake_server_ptr =
  57       reinterpret_cast<fake_server::FakeServer*>(fake_server);
  58   delete fake_server_ptr;
  59 }
  60
  61 jboolean FakeServerHelperAndroid::VerifyEntityCountByTypeAndName(
  62     JNIEnv* env,
  63     jobject obj,
  64     jlong fake_server,
  65     jlong count,
  66     jstring model_type_string,
  67     jstring name) {
  68   syncer::ModelType model_type;
  69   if (!NotificationTypeToRealModelType(base::android::ConvertJavaStringToUTF8(
  70       env, model_type_string), &model_type)) {
  71     LOG(WARNING) << "Invalid ModelType string.";
  72     return false;
  73   }
  74   fake_server::FakeServer* fake_server_ptr =
  75       reinterpret_cast<fake_server::FakeServer*>(fake_server);
  76   fake_server::FakeServerVerifier fake_server_verifier(fake_server_ptr);
  77   testing::AssertionResult result =
  78       fake_server_verifier.VerifyEntityCountByTypeAndName(
  79           count, model_type, base::android::ConvertJavaStringToUTF8(env, name));
  80
  81   if (!result)
  82     LOG(WARNING) << result.message();
  83
  84   return result;
  85 }
  86
  87 jboolean FakeServerHelperAndroid::VerifySessions(
  88     JNIEnv* env,
  89     jobject obj,
  90     jlong fake_server,
  91     jobjectArray url_array) {
  92   std::multiset<std::string> tab_urls;
  93   for (int i = 0; i < env->GetArrayLength(url_array); i++) {
  94     jstring s = (jstring) env->GetObjectArrayElement(url_array, i);
  95     tab_urls.insert(base::android::ConvertJavaStringToUTF8(env, s));
  96   }
  97   fake_server::SessionsHierarchy expected_sessions;
  98   expected_sessions.AddWindow(tab_urls);
  99
 100   fake_server::FakeServer* fake_server_ptr =
 101       reinterpret_cast<fake_server::FakeServer*>(fake_server);
 102   fake_server::FakeServerVerifier fake_server_verifier(fake_server_ptr);
 103   testing::AssertionResult result =
 104       fake_server_verifier.VerifySessions(expected_sessions);
 105
 106   if (!result)
 107     LOG(WARNING) << result.message();
 108
 109   return result;
 110 }
 111
 112 void FakeServerHelperAndroid::InjectUniqueClientEntity(
 113     JNIEnv* env,
 114     jobject obj,
 115     jlong fake_server,
 116     jstring name,
 117     jbyteArray serialized_entity_specifics) {
 118   fake_server::FakeServer* fake_server_ptr =
 119       reinterpret_cast<fake_server::FakeServer*>(fake_server);
 120
 121   sync_pb::EntitySpecifics entity_specifics;
 122   DeserializeEntitySpecifics(env, serialized_entity_specifics,
 123                              entity_specifics);
 124
 125   fake_server_ptr->InjectEntity(
 126       fake_server::UniqueClientEntity::CreateForInjection(
 127           base::android::ConvertJavaStringToUTF8(env, name), entity_specifics));
 128 }
 129
 130 void FakeServerHelperAndroid::ModifyEntitySpecifics(
 131     JNIEnv* env,
 132     jobject obj,
 133     jlong fake_server,
 134     jstring id,
 135     jbyteArray serialized_entity_specifics) {
 136   fake_server::FakeServer* fake_server_ptr =
 137       reinterpret_cast<fake_server::FakeServer*>(fake_server);
 138
 139   sync_pb::EntitySpecifics entity_specifics;
 140   DeserializeEntitySpecifics(env, serialized_entity_specifics,
 141                              entity_specifics);
 142
 143   fake_server_ptr->ModifyEntitySpecifics(
 144       base::android::ConvertJavaStringToUTF8(env, id), entity_specifics);
 145 }
 146
 147 void FakeServerHelperAndroid::DeserializeEntitySpecifics(
 148     JNIEnv* env,
 149     jbyteArray serialized_entity_specifics,
 150     sync_pb::EntitySpecifics& entity_specifics) {
 151   int specifics_bytes_length = env->GetArrayLength(serialized_entity_specifics);
 152   jbyte* specifics_bytes =
 153       env->GetByteArrayElements(serialized_entity_specifics, NULL);
 154   std::string specifics_string(reinterpret_cast<char *>(specifics_bytes),
 155                                specifics_bytes_length);
 156
 157   if (!entity_specifics.ParseFromString(specifics_string))
 158     NOTREACHED() << "Could not deserialize EntitySpecifics";
 159 }
 160
 161 void FakeServerHelperAndroid::InjectBookmarkEntity(
 162     JNIEnv* env,
 163     jobject obj,
 164     jlong fake_server,
 165     jstring title,
 166     jstring url,
 167     jstring parent_id) {
 168   fake_server::FakeServer* fake_server_ptr =
 169       reinterpret_cast<fake_server::FakeServer*>(fake_server);
 170   fake_server_ptr->InjectEntity(
 171       CreateBookmarkEntity(env, title, url, parent_id));
 172 }
 173
 174 void FakeServerHelperAndroid::ModifyBookmarkEntity(JNIEnv* env,
 175                                                    jobject obj,
 176                                                    jlong fake_server,
 177                                                    jstring entity_id,
 178                                                    jstring title,
 179                                                    jstring url,
 180                                                    jstring parent_id) {
 181   fake_server::FakeServer* fake_server_ptr =
 182       reinterpret_cast<fake_server::FakeServer*>(fake_server);
 183   scoped_ptr<fake_server::FakeServerEntity> bookmark =
 184       CreateBookmarkEntity(env, title, url, parent_id);
 185   sync_pb::SyncEntity proto;
 186   bookmark->SerializeAsProto(&proto);
 187   fake_server_ptr->ModifyEntitySpecifics(
 188       base::android::ConvertJavaStringToUTF8(env, entity_id),
 189       proto.specifics());
 190 }
 191
 192 scoped_ptr<fake_server::FakeServerEntity>
 193 FakeServerHelperAndroid::CreateBookmarkEntity(JNIEnv* env,
 194                                               jstring title,
 195                                               jstring url,
 196                                               jstring parent_id) {
 197   std::string url_as_string = base::android::ConvertJavaStringToUTF8(env, url);
 198   GURL gurl = GURL(url_as_string);
 199   if (!gurl.is_valid()) {
 200     NOTREACHED() << "The given string (" << url_as_string
 201                  << ") is not a valid URL.";
 202   }
 203
 204   fake_server::EntityBuilderFactory entity_builder_factory;
 205   fake_server::BookmarkEntityBuilder bookmark_builder =
 206       entity_builder_factory.NewBookmarkEntityBuilder(
 207           base::android::ConvertJavaStringToUTF8(env, title));
 208   bookmark_builder.SetParentId(
 209           base::android::ConvertJavaStringToUTF8(env, parent_id));
 210   return bookmark_builder.BuildBookmark(gurl);
 211 }
 212
 213 base::android::ScopedJavaLocalRef<jstring>
 214 FakeServerHelperAndroid::GetBookmarkBarFolderId(
 215     JNIEnv* env,
 216     jobject obj,
 217     jlong fake_server) {
 218   fake_server::FakeServer* fake_server_ptr =
 219       reinterpret_cast<fake_server::FakeServer*>(fake_server);
 220   return base::android::ConvertUTF8ToJavaString(
 221       env, fake_server_ptr->GetBookmarkBarFolderId());
 222 }
 223
 224 void FakeServerHelperAndroid::DeleteEntity(
 225     JNIEnv* env,
 226     jobject obj,
 227     jlong fake_server,
 228     jstring id) {
 229   fake_server::FakeServer* fake_server_ptr =
 230       reinterpret_cast<fake_server::FakeServer*>(fake_server);
 231   std::string native_id = base::android::ConvertJavaStringToUTF8(env, id);
 232   fake_server_ptr->InjectEntity(
 233       fake_server::TombstoneEntity::Create(native_id));
 234 }
 235
 236 // static
 237 bool FakeServerHelperAndroid::Register(JNIEnv* env) {
 238   return RegisterNativesImpl(env);
 239 }