webapps: initial addition of splash screen icon downloading

chrome/browser/android/banners/app_banner_manager_android.cc

 // Copyright 2015 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/banners/app_banner_manager_android.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/command_line.h"
 #include "base/metrics/field_trial.h"
@@ skipping 13 matching lines @@
 
 const char kPlayPlatform[] = "play";
 const char kReferrerName[] = "referrer";
 const char kIdName[] = "id";
 const char kPlayInlineReferrer[] = "playinline=chrome_inline";
 
 }  // anonymous namespace
 
 namespace banners {
 
-AppBannerManagerAndroid::AppBannerManagerAndroid(JNIEnv* env,
-                                                 jobject obj,
-                                                 int icon_size)
-    : AppBannerManager(icon_size),
+AppBannerManagerAndroid::AppBannerManagerAndroid(
+    JNIEnv* env,
+    jobject obj,
+    int ideal_splash_image_size_in_dp,
+    int ideal_icon_size_in_dp)
+    : AppBannerManager(ideal_icon_size_in_dp),
+      ideal_splash_image_size_in_dp_(ideal_splash_image_size_in_dp),
       weak_java_banner_view_manager_(env, obj) {
 }
 
 AppBannerManagerAndroid::~AppBannerManagerAndroid() {
 }
 
 void AppBannerManagerAndroid::Destroy(JNIEnv* env, jobject obj) {
   delete this;
 }
 
@@ skipping 37 matching lines @@
     referrer.append("&").append(kPlayInlineReferrer);
 
   ScopedJavaLocalRef<jstring> jurl(
       ConvertUTF8ToJavaString(env, data_fetcher()->validated_url().spec()));
   ScopedJavaLocalRef<jstring> jpackage(
       ConvertUTF8ToJavaString(env, id));
   ScopedJavaLocalRef<jstring> jreferrer(
       ConvertUTF8ToJavaString(env, referrer));
   Java_AppBannerManager_fetchAppDetails(env, jobj.obj(), jurl.obj(),
                                         jpackage.obj(), jreferrer.obj(),
-                                        ideal_icon_size());
+                                        ideal_icon_size_in_dp());
   return true;
 }
 
 bool AppBannerManagerAndroid::CheckPlatformAndId(const std::string& platform,
                                                  const std::string& id) {
   if (platform != kPlayPlatform) {
     banners::OutputDeveloperDebugMessage(
         web_contents(), platform + banners::kIgnoredNotSupportedOnAndroid);
     return false;
   }
@@ skipping 28 matching lines @@
     std::string key_str(url_spec, key.begin, key.len);
     std::string value_str(url_spec, value.begin, value.len);
     if (key_str == name)
       return value_str;
   }
   return "";
 }
 
 AppBannerDataFetcher* AppBannerManagerAndroid::CreateAppBannerDataFetcher(
     base::WeakPtr<Delegate> weak_delegate,
-    const int ideal_icon_size) {
+    const int ideal_icon_size_in_dp) {
   return new AppBannerDataFetcherAndroid(web_contents(), weak_delegate,
-                                         ideal_icon_size);
+                                         ideal_splash_image_size_in_dp_,
+                                         ideal_icon_size_in_dp);
 }
 
 bool AppBannerManagerAndroid::OnAppDetailsRetrieved(JNIEnv* env,
                                                     jobject obj,
                                                     jobject japp_data,
                                                     jstring japp_title,
                                                     jstring japp_package,
                                                     jstring jicon_url) {
   if (!CheckFetcherMatchesContents())
     return false;
@@ skipping 12 matching lines @@
 
 bool AppBannerManagerAndroid::IsFetcherActive(JNIEnv* env, jobject obj) {
   return AppBannerManager::IsFetcherActive();
 }
 
 // static
 bool AppBannerManagerAndroid::Register(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }
 
-jlong Init(JNIEnv* env, const JavaParamRef<jobject>& obj, jint icon_size) {
+jlong Init(JNIEnv* env,
+           const JavaParamRef<jobject>& obj,
+           jint ideal_splash_image_size_in_dp,
+           jint ideal_icon_size_in_dp) {
   AppBannerManagerAndroid* manager =
-      new AppBannerManagerAndroid(env, obj, icon_size);
+      new AppBannerManagerAndroid(env, obj,
+          ideal_splash_image_size_in_dp, ideal_icon_size_in_dp);
   return reinterpret_cast<intptr_t>(manager);
 }
 
 void SetTimeDeltaForTesting(JNIEnv* env,
                             const JavaParamRef<jclass>& clazz,
                             jint days) {
   AppBannerDataFetcher::SetTimeDeltaForTesting(days);
 }
 
 void DisableSecureSchemeCheckForTesting(JNIEnv* env,
                                         const JavaParamRef<jclass>& clazz) {
   AppBannerManager::DisableSecureSchemeCheckForTesting();
 }
 
 void SetEngagementWeights(JNIEnv* env,
                           const JavaParamRef<jclass>& clazz,
                           jdouble direct_engagement,
                           jdouble indirect_engagement) {
   AppBannerManager::SetEngagementWeights(direct_engagement,
                                          indirect_engagement);
 }
 
 jboolean IsEnabled(JNIEnv* env, const JavaParamRef<jclass>& clazz) {
   return base::FieldTrialList::FindFullName("AppBanners") == "Enabled";
 }
 
 }  // namespace banners