Remove more dead app list code.

chrome/browser/ui/app_list/app_list_syncable_service.cc

 // Copyright 2013 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/app_list_syncable_service.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/macros.h"
@@ skipping 20 matching lines @@
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/uninstall_reason.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/one_shot_event.h"
 #include "ui/app_list/app_list_folder_item.h"
 #include "ui/app_list/app_list_item.h"
 #include "ui/app_list/app_list_model.h"
 #include "ui/app_list/app_list_model_observer.h"
 #include "ui/app_list/app_list_switches.h"
 #include "ui/base/l10n/l10n_util.h"
-
-#if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/arc/arc_util.h"
 #include "chrome/browser/chromeos/file_manager/app_id.h"
 #include "chrome/browser/chromeos/genius_app/app_id.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_item.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_list_prefs.h"
 #include "chrome/browser/ui/app_list/arc/arc_app_model_builder.h"
-#endif
 
 using syncer::SyncChange;
 
 namespace app_list {
 
 namespace {
 
 const char kNameKey[] = "name";
 const char kParentIdKey[] = "parent_id";
 const char kPositionKey[] = "position";
@@ skipping 63 matching lines @@
                                            item->item_id,
                                            specifics);
 }
 
 bool AppIsDefault(ExtensionService* service, const std::string& id) {
   return service && extensions::ExtensionPrefs::Get(service->profile())
                         ->WasInstalledByDefault(id);
 }
 
 bool IsUnRemovableDefaultApp(const std::string& id) {
-  if (id == extension_misc::kChromeAppId ||
-      id == extensions::kWebStoreAppId)
-    return true;
-#if defined(OS_CHROMEOS)
-  if (id == file_manager::kFileManagerAppId || id == genius_app::kGeniusAppId)
-    return true;
-#endif
-  return false;
+  return id == extension_misc::kChromeAppId ||
+         id == extensions::kWebStoreAppId ||
+         id == file_manager::kFileManagerAppId ||
+         id == genius_app::kGeniusAppId;
 }
 
 void UninstallExtension(ExtensionService* service, const std::string& id) {
   if (service) {
     ExtensionService::UninstallExtensionHelper(
         service, id, extensions::UNINSTALL_REASON_SYNC);
   }
 }
 
 bool GetAppListItemType(AppListItem* item,
                         sync_pb::AppListSpecifics::AppListItemType* type) {
   const char* item_type = item->GetItemType();
   if (item_type == ExtensionAppItem::kItemType) {
     *type = sync_pb::AppListSpecifics::TYPE_APP;
-#if defined(OS_CHROMEOS)
   } else if (item_type == ArcAppItem::kItemType) {
     *type = sync_pb::AppListSpecifics::TYPE_APP;
-#endif
   } else if (item_type == AppListFolderItem::kItemType) {
     *type = sync_pb::AppListSpecifics::TYPE_FOLDER;
   } else {
     LOG(ERROR) << "Unrecognized model type: " << item_type;
     return false;
   }
   return true;
 }
 
 bool IsDriveAppSyncId(const std::string& sync_id) {
@@ skipping 80 matching lines @@
 
   void OnAppListItemWillBeDeleted(AppListItem* item) override {
     DCHECK(!adding_item_);
     VLOG(2) << owner_ << " OnAppListItemDeleted: " << item->ToDebugString();
     // Don't sync folder removal in case the folder still exists on another
     // device (e.g. with device specific items in it). Empty folders will be
     // deleted when the last item is removed (in PruneEmptySyncFolders()).
     if (item->GetItemType() == AppListFolderItem::kItemType)
       return;
 
-#if defined(OS_CHROMEOS)
     if (item->GetItemType() == ArcAppItem::kItemType) {
       // Don't sync remove changes coming as result of disabling ARC.
       if (!arc::IsArcPlayStoreEnabledForProfile(owner_->profile()))
         return;
     }
-#endif
 
     owner_->RemoveSyncItem(item->id());
   }
 
   void OnAppListItemUpdated(AppListItem* item) override {
     if (adding_item_) {
       // Adding an item may trigger update notifications which should be
       // ignored.
       DCHECK_EQ(adding_item_, item);
       return;
@@ skipping 110 matching lines @@
 void AppListSyncableService::BuildModel() {
   InitFromLocalStorage();
 
   // TODO(calamity): make this a DCHECK after a dev channel release.
   CHECK(IsExtensionServiceReady());
   AppListControllerDelegate* controller = NULL;
   AppListService* service = AppListService::Get();
   if (service)
     controller = service->GetControllerDelegate();
   apps_builder_.reset(new ExtensionAppModelBuilder(controller));
-#if defined(OS_CHROMEOS)
   if (arc::IsArcAllowedForProfile(profile_))
     arc_apps_builder_.reset(new ArcAppModelBuilder(controller));
-#endif
   DCHECK(profile_);
   if (app_list::switches::IsAppListSyncEnabled()) {
     VLOG(1) << this << ": AppListSyncableService: InitializeWithService.";
     SyncStarted();
     apps_builder_->InitializeWithService(this, model_.get());
-#if defined(OS_CHROMEOS)
     if (arc_apps_builder_.get())
       arc_apps_builder_->InitializeWithService(this, model_.get());
-#endif
   } else {
     VLOG(1) << this << ": AppListSyncableService: InitializeWithProfile.";
     apps_builder_->InitializeWithProfile(profile_, model_.get());
-#if defined(OS_CHROMEOS)
     if (arc_apps_builder_.get())
       arc_apps_builder_->InitializeWithProfile(profile_, model_.get());
-#endif
   }
 
   if (app_list::switches::IsDriveAppsInAppListEnabled())
     drive_app_provider_.reset(new DriveAppProvider(profile_, this));
 
   HandleUpdateFinished();
 }
 
 void AppListSyncableService::AddObserverAndStart(Observer* observer) {
   observer_list_.AddObserver(observer);
@@ skipping 796 matching lines @@
   }
 
   const syncer::StringOrdinal oem_ordinal =
       web_store_app_item->position().CreateAfter();
   VLOG(1) << "Placing OEM Folder at: " << item_list->item_count()
           << " position: " << oem_ordinal.ToDebugString();
   return oem_ordinal;
 }
 
 bool AppListSyncableService::AppIsOem(const std::string& id) {
-#if defined(OS_CHROMEOS)
   const ArcAppListPrefs* arc_prefs = ArcAppListPrefs::Get(profile_);
   if (arc_prefs && arc_prefs->IsOem(id))
     return true;
-#endif
 
   if (!extension_system_->extension_service())
     return false;
   const extensions::Extension* extension =
       extension_system_->extension_service()->GetExtensionById(id, true);
   return extension && extension->was_installed_by_oem();
 }
 
 std::string AppListSyncableService::SyncItem::ToString() const {
   std::string res = item_id.substr(0, 8);
   if (item_type == sync_pb::AppListSpecifics::TYPE_REMOVE_DEFAULT_APP) {
     res += " { RemoveDefault }";
   } else {
     res += " { " + item_name + " }";
     res += " [" + item_ordinal.ToDebugString() + "]";
     if (!parent_id.empty())
       res += " <" + parent_id.substr(0, 8) + ">";
     res += " [" + item_pin_ordinal.ToDebugString() + "]";
   }
   return res;
 }
 
 }  // namespace app_list