arc: Revamp the ArcBridgeService interface

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 <unordered_map>
@@ skipping 90 matching lines @@
 
 bool InstallIconFromFileThread(const std::string& app_id,
                                ui::ScaleFactor scale_factor,
                                const base::FilePath& icon_path,
                                const std::vector<uint8_t>& content_png) {
   DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
   DCHECK(!content_png.empty());
 
   base::CreateDirectory(icon_path.DirName());
 
-  int wrote = base::WriteFile(icon_path,
-                              reinterpret_cast<const char*>(&content_png[0]),
-                              content_png.size());
+  int wrote =
+      base::WriteFile(icon_path, reinterpret_cast<const char*>(&content_png[0]),
+                      content_png.size());
   if (wrote != static_cast<int>(content_png.size())) {
     VLOG(2) << "Failed to write ARC icon file: " << icon_path.MaybeAsASCII()
             << ".";
     if (!base::DeleteFile(icon_path, false))
       VLOG(2) << "Couldn't delete broken icon file" << icon_path.MaybeAsASCII()
               << ".";
     return false;
   }
 
   return true;
@@ skipping 103 matching lines @@
   if (!auth_service)
     return;
 
   if (auth_service->state() != arc::ArcAuthService::State::NOT_INITIALIZED)
     OnOptInEnabled(auth_service->IsArcEnabled());
   auth_service->AddObserver(this);
 
   arc::ArcBridgeService* bridge_service = arc::ArcBridgeService::Get();
   DCHECK(bridge_service);
 
+  bridge_service->app()->AddObserver(this);
   bridge_service->AddObserver(this);
   if (!bridge_service->ready())
     OnBridgeStopped();
 }
 
 ArcAppListPrefs::~ArcAppListPrefs() {
   arc::ArcBridgeService* bridge_service = arc::ArcBridgeService::Get();
-  if (bridge_service)
+  if (bridge_service) {
     bridge_service->RemoveObserver(this);
+    bridge_service->app()->RemoveObserver(this);
+  }
 
   arc::ArcAuthService* auth_service = arc::ArcAuthService::Get();
   if (auth_service)
     auth_service->RemoveObserver(this);
 }
 
 base::FilePath ArcAppListPrefs::GetAppPath(const std::string& app_id) const {
   return base_path_.AppendASCII(app_id);
 }
 
 base::FilePath ArcAppListPrefs::GetIconPath(
     const std::string& app_id,
     ui::ScaleFactor scale_factor) const {
   const base::FilePath app_path = GetAppPath(app_id);
   switch (scale_factor) {
-  case ui::SCALE_FACTOR_100P:
-    return app_path.AppendASCII("icon_100p.png");
-  case ui::SCALE_FACTOR_125P:
-    return app_path.AppendASCII("icon_125p.png");
-  case ui::SCALE_FACTOR_133P:
-    return app_path.AppendASCII("icon_133p.png");
-  case ui::SCALE_FACTOR_140P:
-    return app_path.AppendASCII("icon_140p.png");
-  case ui::SCALE_FACTOR_150P:
-    return app_path.AppendASCII("icon_150p.png");
-  case ui::SCALE_FACTOR_180P:
-    return app_path.AppendASCII("icon_180p.png");
-  case ui::SCALE_FACTOR_200P:
-    return app_path.AppendASCII("icon_200p.png");
-  case ui::SCALE_FACTOR_250P:
-    return app_path.AppendASCII("icon_250p.png");
-  case ui::SCALE_FACTOR_300P:
-    return app_path.AppendASCII("icon_300p.png");
-  default:
-    NOTREACHED();
-    return base::FilePath();
+    case ui::SCALE_FACTOR_100P:
+      return app_path.AppendASCII("icon_100p.png");
+    case ui::SCALE_FACTOR_125P:
+      return app_path.AppendASCII("icon_125p.png");
+    case ui::SCALE_FACTOR_133P:
+      return app_path.AppendASCII("icon_133p.png");
+    case ui::SCALE_FACTOR_140P:
+      return app_path.AppendASCII("icon_140p.png");
+    case ui::SCALE_FACTOR_150P:
+      return app_path.AppendASCII("icon_150p.png");
+    case ui::SCALE_FACTOR_180P:
+      return app_path.AppendASCII("icon_180p.png");
+    case ui::SCALE_FACTOR_200P:
+      return app_path.AppendASCII("icon_200p.png");
+    case ui::SCALE_FACTOR_250P:
+      return app_path.AppendASCII("icon_250p.png");
+    case ui::SCALE_FACTOR_300P:
+      return app_path.AppendASCII("icon_300p.png");
+    default:
+      NOTREACHED();
+      return base::FilePath();
   }
 }
 
 void ArcAppListPrefs::RequestIcon(const std::string& app_id,
                                   ui::ScaleFactor scale_factor) {
   if (!IsRegistered(app_id)) {
-    VLOG(2) << "Request to load icon for non-registered app: "
-            <<  app_id << ".";
+    VLOG(2) << "Request to load icon for non-registered app: " << app_id << ".";
     return;
   }
 
   // In case app is not ready, defer this request.
   if (!ready_apps_.count(app_id)) {
     request_icon_deferred_[app_id] =
         request_icon_deferred_[app_id] | 1 << scale_factor;
     return;
   }
 
   arc::ArcBridgeService* bridge_service = arc::ArcBridgeService::Get();
   if (!bridge_service) {
     NOTREACHED();
     return;
   }
-  arc::mojom::AppInstance* app_instance = bridge_service->app_instance();
+  arc::mojom::AppInstance* app_instance = bridge_service->app()->instance();
   if (!app_instance) {
     // AppInstance should be ready since we have app_id in ready_apps_.
     NOTREACHED();
     return;
   }
 
   std::unique_ptr<AppInfo> app_info = GetApp(app_id);
   if (!app_info) {
-    VLOG(2) << "Failed to get app info: " <<  app_id << ".";
+    VLOG(2) << "Failed to get app info: " << app_id << ".";
     return;
   }
 
   if (app_info->icon_resource_id.empty()) {
     app_instance->RequestAppIcon(
         app_info->package_name, app_info->activity,
         static_cast<arc::mojom::ScaleFactor>(scale_factor));
   } else {
     app_instance->RequestIcon(
         app_info->icon_resource_id,
@@ skipping 13 matching lines @@
 
   std::unique_ptr<AppInfo> app_info = GetApp(app_id);
   if (!app_info) {
     VLOG(2) << "Failed to get app info: " << app_id << ".";
     return;
   }
 
   // In case app is not ready, defer this request.
   if (!ready_apps_.count(app_id)) {
     SetNotificationsEnabledDeferred(prefs_).Put(app_id, enabled);
-    FOR_EACH_OBSERVER(Observer, observer_list_,
-                      OnNotificationsEnabledChanged(
-                          app_info->package_name, enabled));
+    FOR_EACH_OBSERVER(
+        Observer, observer_list_,
+        OnNotificationsEnabledChanged(app_info->package_name, enabled));
     return;
   }
 
   arc::ArcBridgeService* bridge_service = arc::ArcBridgeService::Get();
   if (!bridge_service) {
     NOTREACHED();
     return;
   }
 
-  arc::mojom::AppInstance* app_instance = bridge_service->app_instance();
+  arc::mojom::AppInstance* app_instance = bridge_service->app()->instance();
   if (!app_instance) {
     // AppInstance should be ready since we have app_id in ready_apps_.
     NOTREACHED();
     return;
   }
 
-  if (bridge_service->app_version() < kSetNotificationsEnabledMinVersion) {
+  if (bridge_service->app()->version() < kSetNotificationsEnabledMinVersion) {
     VLOG(2) << "app version is too small to set notifications enabled.";
     return;
   }
 
   SetNotificationsEnabledDeferred(prefs_).Remove(app_id);
   app_instance->SetNotificationsEnabled(app_info->package_name, enabled);
 }
 
 void ArcAppListPrefs::AddObserver(Observer* observer) {
   observer_list_.AddObserver(observer);
@@ skipping 40 matching lines @@
   if (!IsArcEnabled())
     return std::vector<std::string>();
   return GetAppIdsNoArcEnabledCheck();
 }
 
 std::vector<std::string> ArcAppListPrefs::GetAppIdsNoArcEnabledCheck() const {
   std::vector<std::string> ids;
 
   // crx_file::id_util is de-facto utility for id generation.
   const base::DictionaryValue* apps = prefs_->GetDictionary(prefs::kArcApps);
-  for (base::DictionaryValue::Iterator app_id(*apps);
-       !app_id.IsAtEnd(); app_id.Advance()) {
+  for (base::DictionaryValue::Iterator app_id(*apps); !app_id.IsAtEnd();
+       app_id.Advance()) {
     if (!crx_file::id_util::IdIsValid(app_id.key()))
       continue;
 
     ids.push_back(app_id.key());
   }
 
   return ids;
 }
 
 std::unique_ptr<ArcAppListPrefs::AppInfo> ArcAppListPrefs::GetApp(
@@ skipping 77 matching lines @@
   ScopedArcPrefUpdate update(prefs_, app_id, prefs::kArcApps);
   base::DictionaryValue* app_dict = update.Get();
   const std::string string_value = base::Int64ToString(time.ToInternalValue());
   app_dict->SetString(kLastLaunchTime, string_value);
 }
 
 void ArcAppListPrefs::DisableAllApps() {
   std::set<std::string> old_ready_apps;
   old_ready_apps.swap(ready_apps_);
   for (auto& app_id : old_ready_apps) {
-    FOR_EACH_OBSERVER(Observer,
-                      observer_list_,
+    FOR_EACH_OBSERVER(Observer, observer_list_,
                       OnAppReadyChanged(app_id, false));
   }
 }
 
 void ArcAppListPrefs::NotifyRegisteredApps() {
   if (apps_restored_)
     return;
 
   DCHECK(ready_apps_.empty());
   std::vector<std::string> app_ids = GetAppIdsNoArcEnabledCheck();
   for (const auto& app_id : app_ids) {
     std::unique_ptr<AppInfo> app_info = GetApp(app_id);
     if (!app_info) {
       NOTREACHED();
       continue;
     }
-    FOR_EACH_OBSERVER(Observer,
-                      observer_list_,
+    FOR_EACH_OBSERVER(Observer, observer_list_,
                       OnAppRegistered(app_id, *app_info));
   }
 
   apps_restored_ = true;
 }
 
 void ArcAppListPrefs::RemoveAllApps() {
   std::vector<std::string> app_ids = GetAppIdsNoArcEnabledCheck();
   for (const auto& app_id : app_ids)
     RemoveApp(app_id);
 }
 
 void ArcAppListPrefs::OnOptInEnabled(bool enabled) {
   if (enabled)
     NotifyRegisteredApps();
   else
     RemoveAllApps();
 }
 
 void ArcAppListPrefs::OnBridgeStopped() {
   DisableAllApps();
 }
 
-void ArcAppListPrefs::OnAppInstanceReady() {
+void ArcAppListPrefs::OnInstanceReady() {
   arc::ArcBridgeService* bridge_service = arc::ArcBridgeService::Get();
   if (!bridge_service) {
     NOTREACHED();
     return;
   }
-  arc::mojom::AppInstance* app_instance = bridge_service->app_instance();
+  arc::mojom::AppInstance* app_instance = bridge_service->app()->instance();
   if (!app_instance) {
     VLOG(2) << "Request to refresh app list when bridge service is not ready.";
     return;
   }
 
   app_instance->Init(binding_.CreateInterfacePtrAndBind());
   app_instance->RefreshAppList();
 }
 
-void ArcAppListPrefs::OnAppInstanceClosed() {
+void ArcAppListPrefs::OnInstanceClosed() {
   ready_apps_.clear();
 }
 
 void ArcAppListPrefs::AddAppAndShortcut(
     const std::string& name,
     const std::string& package_name,
     const std::string& activity,
     const std::string& intent_uri,
     const std::string& icon_resource_id,
     const bool sticky,
@@ skipping 22 matching lines @@
   app_dict->SetBoolean(kSticky, sticky);
   app_dict->SetBoolean(kNotificationsEnabled, notifications_enabled);
   app_dict->SetBoolean(kShortcut, shortcut);
   app_dict->SetInteger(kOrientationLock, static_cast<int>(orientation_lock));
 
   // 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_,
+    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(), sticky, notifications_enabled, true,
                      arc::ShouldShowInLauncher(app_id), shortcut,
                      orientation_lock);
     FOR_EACH_OBSERVER(Observer,
                       observer_list_,
                       OnAppRegistered(app_id, app_info));
   }
@@ skipping 26 matching lines @@
   ready_apps_.erase(app_id);
 
   // Remove from prefs.
   DictionaryPrefUpdate update(prefs_, prefs::kArcApps);
   base::DictionaryValue* apps = update.Get();
   const bool removed = apps->Remove(app_id, nullptr);
   DCHECK(removed);
   // app_id may be released by observers, get the path first.
   const base::FilePath app_path = GetAppPath(app_id);
 
-  FOR_EACH_OBSERVER(Observer,
-                    observer_list_,
-                    OnAppRemoved(app_id));
+  FOR_EACH_OBSERVER(Observer, observer_list_, OnAppRemoved(app_id));
 
   // Remove local data on file system.
   content::BrowserThread::GetBlockingPool()->PostTask(
-      FROM_HERE,
-      base::Bind(&DeleteAppFolderFromFileThread, app_path));
+      FROM_HERE, base::Bind(&DeleteAppFolderFromFileThread, app_path));
 }
 
 void ArcAppListPrefs::OnAppListRefreshed(
     mojo::Array<arc::mojom::AppInfoPtr> apps) {
   DCHECK(IsArcEnabled());
   std::vector<std::string> old_apps = GetAppIds();
 
   ready_apps_.clear();
   for (const auto& app : apps) {
     // TODO(oshima): Do we have to update orientation?
@@ skipping 53 matching lines @@
   AddAppAndShortcut(shortcut->name, shortcut->package_name,
                     std::string() /* activity */, shortcut->intent_uri,
                     shortcut->icon_resource_id, false /* sticky */,
                     false /* notifications_enabled */, true /* shortcut */,
                     arc::mojom::OrientationLock::NONE);
 }
 
 void ArcAppListPrefs::OnPackageRemoved(const mojo::String& package_name) {
   const base::DictionaryValue* apps = prefs_->GetDictionary(prefs::kArcApps);
   std::vector<std::string> apps_to_remove;
-  for (base::DictionaryValue::Iterator app_it(*apps);
-       !app_it.IsAtEnd(); app_it.Advance()) {
+  for (base::DictionaryValue::Iterator app_it(*apps); !app_it.IsAtEnd();
+       app_it.Advance()) {
     const base::Value* value = &app_it.value();
     const base::DictionaryValue* app;
     if (!value->GetAsDictionary(&app)) {
       NOTREACHED();
       continue;
     }
 
     std::string app_package;
     if (!app->GetString(kPackageName, &app_package)) {
       NOTREACHED();
@@ skipping 40 matching lines @@
     return;
   }
 
   InstallIcon(app_id, static_cast<ui::ScaleFactor>(scale_factor),
               icon_png_data.To<std::vector<uint8_t>>());
 }
 
 void ArcAppListPrefs::OnTaskCreated(int32_t task_id,
                                     const mojo::String& package_name,
                                     const mojo::String& activity) {
-  FOR_EACH_OBSERVER(Observer,
-                    observer_list_,
+  FOR_EACH_OBSERVER(Observer, observer_list_,
                     OnTaskCreated(task_id, package_name, activity));
 }
 
 void ArcAppListPrefs::OnTaskDestroyed(int32_t task_id) {
   FOR_EACH_OBSERVER(Observer, observer_list_, OnTaskDestroyed(task_id));
 }
 
 void ArcAppListPrefs::OnTaskSetActive(int32_t task_id) {
   FOR_EACH_OBSERVER(Observer, observer_list_, OnTaskSetActive(task_id));
 }
 
 void ArcAppListPrefs::OnNotificationsEnabledChanged(
-    const mojo::String& package_name, bool enabled) {
+    const mojo::String& package_name,
+    bool enabled) {
   const base::DictionaryValue* apps = prefs_->GetDictionary(prefs::kArcApps);
-  for (base::DictionaryValue::Iterator app(*apps);
-       !app.IsAtEnd(); app.Advance()) {
+  for (base::DictionaryValue::Iterator app(*apps); !app.IsAtEnd();
+       app.Advance()) {
     const base::DictionaryValue* app_dict;
     std::string app_package_name;
     if (!app.value().GetAsDictionary(&app_dict) ||
         !app_dict->GetString(kPackageName, &app_package_name)) {
       NOTREACHED();
       continue;
     }
     if (app_package_name != package_name) {
       continue;
     }
@@ skipping 47 matching lines @@
     packages.push_back(package.key());
   }
 
   return packages;
 }
 
 void ArcAppListPrefs::InstallIcon(const std::string& app_id,
                                   ui::ScaleFactor scale_factor,
                                   const std::vector<uint8_t>& content_png) {
   base::FilePath icon_path = GetIconPath(app_id, scale_factor);
-  base::PostTaskAndReplyWithResult(content::BrowserThread::GetBlockingPool(),
-                                   FROM_HERE,
-                                   base::Bind(&InstallIconFromFileThread,
-                                              app_id,
-                                              scale_factor,
-                                              icon_path,
-                                              content_png),
-                                   base::Bind(&ArcAppListPrefs::OnIconInstalled,
-                                              weak_ptr_factory_.GetWeakPtr(),
-                                              app_id,
-                                              scale_factor));
+  base::PostTaskAndReplyWithResult(
+      content::BrowserThread::GetBlockingPool(), FROM_HERE,
+      base::Bind(&InstallIconFromFileThread, app_id, scale_factor, icon_path,
+                 content_png),
+      base::Bind(&ArcAppListPrefs::OnIconInstalled,
+                 weak_ptr_factory_.GetWeakPtr(), app_id, scale_factor));
 }
 
 void ArcAppListPrefs::OnIconInstalled(const std::string& app_id,
                                       ui::ScaleFactor scale_factor,
                                       bool install_succeed) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (!install_succeed)
     return;
 
-  FOR_EACH_OBSERVER(Observer,
-                    observer_list_,
+  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 std::string& intent_uri,
                                   const std::string& icon_resource_id,
                                   const base::Time& last_launch_time,
                                   bool sticky,
@@ skipping 24 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) {}