[ARC] Add "(beta)" string to Play Store.

chrome/browser/ui/app_list/arc/arc_app_list_prefs.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/ui/app_list/arc/arc_app_list_prefs.h"
 
 #include <stddef.h>
 
 #include <string>
 
 #include "base/files/file_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task_runner_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_list/app_list_service.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_list_prefs_factory.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_utils.h"
 #include "chrome/browser/ui/app_list/arc/arc_package_syncable_service.h"
 #include "chrome/common/pref_names.h"
+#include "chrome/grit/generated_resources.h"
 #include "components/arc/arc_bridge_service.h"
 #include "components/crx_file/id_util.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "content/public/browser/browser_thread.h"
+#include "ui/base/l10n/l10n_util.h"
 
 namespace {
 
 const char kActivity[] = "activity";
 const char kIconResourceId[] = "icon_resource_id";
 const char kInstallTime[] = "install_time";
 const char kIntentUri[] = "intent_uri";
 const char kLastBackupAndroidId[] = "last_backup_android_id";
 const char kLastBackupTime[] = "last_backup_time";
 const char kLastLaunchTime[] = "lastlaunchtime";
@@ skipping 652 matching lines @@
     const std::string& activity,
     const std::string& intent_uri,
     const std::string& icon_resource_id,
     const bool sticky,
     const bool notifications_enabled,
     const bool shortcut,
     const bool launchable,
     const arc::mojom::OrientationLock orientation_lock) {
   const std::string app_id = shortcut ? GetAppId(package_name, intent_uri)
                                       : GetAppId(package_name, activity);
+
+  // |name_beta| will be only used on M53 and will be reverted on later version.
+  std::string name_beta = name;
+  if (app_id == arc::kPlayStoreAppId) {
+    name_beta = name + " (" +

[xiyuan, 2016/09/07 22:56:36]

Don't like the concatenation but don't have a better way. :(

Also, use |name_beta| in other places looks strange, maybe rename it to
something like |updated_name| or |actual_name|.

[xdai1, 2016/09/07 23:25:01]

Renamed it.

+                l10n_util::GetStringUTF8(IDS_ABOUT_PAGE_CURRENT_CHANNEL_BETA) +
+                ")";
+  }
+
   const bool was_registered = IsRegistered(app_id);
   if (was_registered) {
     std::unique_ptr<ArcAppListPrefs::AppInfo> app_old_info = GetApp(app_id);
     DCHECK(app_old_info);
     DCHECK(launchable);
-    if (name != app_old_info->name) {
+    if (name_beta != app_old_info->name) {
       FOR_EACH_OBSERVER(Observer, observer_list_,
-                        OnAppNameUpdated(app_id, name));
+                        OnAppNameUpdated(app_id, name_beta));
     }
   }
 
   ScopedArcPrefUpdate update(prefs_, app_id, prefs::kArcApps);
   base::DictionaryValue* app_dict = update.Get();
-  app_dict->SetString(kName, name);
+  app_dict->SetString(kName, name_beta);
   app_dict->SetString(kPackageName, package_name);
   app_dict->SetString(kActivity, activity);
   app_dict->SetString(kIntentUri, intent_uri);
   app_dict->SetString(kIconResourceId, icon_resource_id);
   app_dict->SetBoolean(kSticky, sticky);
   app_dict->SetBoolean(kNotificationsEnabled, notifications_enabled);
   app_dict->SetBoolean(kShortcut, shortcut);
   app_dict->SetBoolean(kLaunchable, launchable);
   app_dict->SetInteger(kOrientationLock, static_cast<int>(orientation_lock));
 
   // Note the install time is the first time the Chrome OS sees the app, not the
   // actual install time in Android side.
   if (GetInstallTime(app_id).is_null()) {
     std::string install_time_str =
         base::Int64ToString(base::Time::Now().ToInternalValue());
     app_dict->SetString(kInstallTime, install_time_str);
   }
 
   // From now, app is available.
   const bool was_disabled = ready_apps_.count(app_id) == 0;
   if (was_disabled)
     ready_apps_.insert(app_id);
 
   if (was_registered) {
     if (was_disabled) {
       FOR_EACH_OBSERVER(Observer, observer_list_,
                         OnAppReadyChanged(app_id, true));
     }
   } else {
-    AppInfo app_info(name, package_name, activity, intent_uri, icon_resource_id,
-                     base::Time(), GetInstallTime(app_id), sticky,
-                     notifications_enabled, true,
+    AppInfo app_info(name_beta, package_name, activity, intent_uri,
+                     icon_resource_id, base::Time(), GetInstallTime(app_id),
+                     sticky, notifications_enabled, true,
                      launchable && arc::ShouldShowInLauncher(app_id), shortcut,
                      launchable, orientation_lock);
     FOR_EACH_OBSERVER(Observer,
                       observer_list_,
                       OnAppRegistered(app_id, app_info));
   }
 
   auto deferred_icons = request_icon_deferred_.find(app_id);
   if (deferred_icons != request_icon_deferred_.end()) {
     for (uint32_t i = ui::SCALE_FACTOR_100P; i < ui::NUM_SCALE_FACTORS; ++i) {
@@ skipping 457 matching lines @@
                                           int64_t last_backup_android_id,
                                           int64_t last_backup_time,
                                           bool should_sync,
                                           bool system)
     : package_name(package_name),
       package_version(package_version),
       last_backup_android_id(last_backup_android_id),
       last_backup_time(last_backup_time),
       should_sync(should_sync),
       system(system) {}