Support uninstalling ARC app from Chrome launcher

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/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/task_runner_util.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_list_prefs_factory.h"
 #include "chrome/common/pref_names.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"
 
 namespace {
 
 const char kName[] = "name";
 const char kPackageName[] = "package_name";
 const char kActivity[] = "activity";
+const char kSticky[] = "sticky";
 const char kLastLaunchTime[] = "lastlaunchtime";
 
 // Provider of write access to a dictionary storing ARC app prefs.
 class ScopedArcAppListPrefUpdate : public DictionaryPrefUpdate {
  public:
   ScopedArcAppListPrefUpdate(PrefService* service, const std::string& id)
       : DictionaryPrefUpdate(service, prefs::kArcApps),
         id_(id) {}
 
   ~ScopedArcAppListPrefUpdate() override {}
@@ skipping 190 matching lines @@
 scoped_ptr<ArcAppListPrefs::AppInfo> ArcAppListPrefs::GetApp(
     const std::string& app_id) const {
   const base::DictionaryValue* app = nullptr;
   const base::DictionaryValue* apps = prefs_->GetDictionary(prefs::kArcApps);
   if (!apps || !apps->GetDictionaryWithoutPathExpansion(app_id, &app))
     return scoped_ptr<AppInfo>();
 
   std::string name;
   std::string package_name;
   std::string activity;
+  bool sticky;

[xiyuan, 2016/03/08 16:40:11]

Set a default value, in case kSticky does not exist and app->GetBoolean() fails.

[victorhsieh0, 2016/03/08 18:02:52]

Done.

   app->GetString(kName, &name);
   app->GetString(kPackageName, &package_name);
   app->GetString(kActivity, &activity);
+  app->GetBoolean(kSticky, &sticky);
 
   base::Time last_launch_time;
   std::string last_launch_time_str;
   if (app->GetString(kLastLaunchTime, &last_launch_time_str)) {
     int64_t last_launch_time_i64 = 0;
     if (base::StringToInt64(last_launch_time_str, &last_launch_time_i64)) {
       last_launch_time = base::Time::FromInternalValue(last_launch_time_i64);
     } else {
       NOTREACHED();
     }
   }
 
   scoped_ptr<AppInfo> app_info(new AppInfo(name,
                                            package_name,
                                            activity,
                                            last_launch_time,
+                                           sticky,
                                            ready_apps_.count(app_id) > 0));
   return app_info;
 }
 
 bool ArcAppListPrefs::IsRegistered(const std::string& app_id) const {
   const base::DictionaryValue* app = nullptr;
   const base::DictionaryValue* apps = prefs_->GetDictionary(prefs::kArcApps);
   if (!apps || !apps->GetDictionary(app_id, &app))
     return false;
 
@@ skipping 59 matching lines @@
       FOR_EACH_OBSERVER(Observer, observer_list_,
                         OnAppNameUpdated(app_id, app.name));
     }
   }
 
   ScopedArcAppListPrefUpdate update(prefs_, app_id);
   base::DictionaryValue* app_dict = update.Get();
   app_dict->SetString(kName, app.name);
   app_dict->SetString(kPackageName, app.package_name);
   app_dict->SetString(kActivity, app.activity);
+  app_dict->SetBoolean(kSticky, app.sticky);
 
   // From now, app is available.
   if (!ready_apps_.count(app_id))
     ready_apps_.insert(app_id);
 
   if (was_registered) {
     FOR_EACH_OBSERVER(Observer,
                       observer_list_,
                       OnAppReadyChanged(app_id, true));
   } else {
     AppInfo app_info(app.name,
                      app.package_name,
                      app.activity,
                      base::Time(),
+                     app.sticky,
                      true);
     FOR_EACH_OBSERVER(Observer,
                       observer_list_,
                       OnAppRegistered(app_id, app_info));
   }
 
   std::map<std::string, uint32_t>::iterator 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 115 matching lines @@
 
   FOR_EACH_OBSERVER(Observer,
                     observer_list_,
                     OnAppIconUpdated(app_id, scale_factor));
 }
 
 ArcAppListPrefs::AppInfo::AppInfo(const std::string& name,
                                   const std::string& package_name,
                                   const std::string& activity,
                                   const base::Time& last_launch_time,
+                                  bool sticky,
                                   bool ready)
     : name(name),
       package_name(package_name),
       activity(activity),
       last_launch_time(last_launch_time),
+      sticky(sticky),
       ready(ready) {}