Lazily build the app list model.

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 "base/command_line.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/apps/drive/drive_app_provider.h"
-#include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/app_list/app_list_prefs.h"
 #include "chrome/browser/ui/app_list/app_list_service.h"
 #include "chrome/browser/ui/app_list/extension_app_item.h"
 #include "chrome/browser/ui/app_list/extension_app_model_builder.h"
 #include "chrome/browser/ui/app_list/model_pref_updater.h"
 #include "chrome/browser/ui/host_desktop.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/grit/generated_resources.h"
-#include "content/public/browser/notification_source.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/uninstall_reason.h"
 #include "extensions/common/constants.h"
 #include "sync/api/sync_change_processor.h"
 #include "sync/api/sync_data.h"
 #include "sync/api/sync_merge_result.h"
 #include "sync/protocol/sync.pb.h"
 #include "ui/app_list/app_list_folder_item.h"
 #include "ui/app_list/app_list_item.h"
@@ skipping 141 matching lines @@
 }
 
 // AppListSyncableService::ModelObserver
 
 class AppListSyncableService::ModelObserver : public AppListModelObserver {
  public:
   explicit ModelObserver(AppListSyncableService* owner)
       : owner_(owner),
         adding_item_(NULL) {
     DVLOG(2) << owner_ << ": ModelObserver Added";
-    owner_->model()->AddObserver(this);
+    owner_->GetModel()->AddObserver(this);
   }
 
   ~ModelObserver() override {
-    owner_->model()->RemoveObserver(this);
+    owner_->GetModel()->RemoveObserver(this);
     DVLOG(2) << owner_ << ": ModelObserver Removed";
   }
 
  private:
   // AppListModelObserver
   void OnAppListItemAdded(AppListItem* item) override {
     DCHECK(!adding_item_);
     adding_item_ = item;  // Ignore updates while adding an item.
     VLOG(2) << owner_ << " OnAppListItemAdded: " << item->ToDebugString();
     owner_->AddOrUpdateFromSyncItem(item);
@@ skipping 38 matching lines @@
       model_(new AppListModel),
       initial_sync_data_processed_(false),
       first_app_list_sync_(true) {
   if (!extension_system) {
     LOG(ERROR) << "AppListSyncableService created with no ExtensionSystem";
     return;
   }
 
   oem_folder_name_ =
       l10n_util::GetStringUTF8(IDS_APP_LIST_OEM_DEFAULT_FOLDER_NAME);
-
-  // Note: model_observer_ is constructed after the initial sync changes are
-  // received in MergeDataAndStartSyncing(). Changes to the model before that
-  // will be synced after the initial sync occurs.
-  if (extension_system->extension_service() &&
-      extension_system->extension_service()->is_ready()) {
-    BuildModel();
-    return;
-  }
-
-  // The extensions for this profile have not yet all been loaded.
-  registrar_.Add(this,
-                 extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED,
-                 content::Source<Profile>(profile));
 }
 
 AppListSyncableService::~AppListSyncableService() {
   // Remove observers.
   model_observer_.reset();
   model_pref_updater_.reset();
 
   STLDeleteContainerPairSecondPointers(sync_items_.begin(), sync_items_.end());
 }
 
 void AppListSyncableService::BuildModel() {
+  DCHECK(extension_system_->extension_service() &&

[tapted, 2015/03/20 11:47:15]

If we're unsure about an obscure startup sequence, we could make this a CHECK
(with a TODO to make it a DCHECK after a dev channel release).

[calamity, 2015/03/23 05:14:49]

Done.

+         extension_system_->extension_service()->is_ready());
   // For now, use the AppListControllerDelegate associated with the native
   // desktop. TODO(stevenjb): Remove ExtensionAppModelBuilder controller
   // dependency and move the dependent methods from AppListControllerDelegate
   // to an extension service delegate associated with this class.
   AppListControllerDelegate* controller = NULL;
   AppListService* service =
       AppListService::Get(chrome::HOST_DESKTOP_TYPE_NATIVE);
   if (service)
     controller = service->GetControllerDelegate();
   apps_builder_.reset(new ExtensionAppModelBuilder(controller));
   DCHECK(profile_);
   if (app_list::switches::IsAppListSyncEnabled()) {
     VLOG(1) << this << ": AppListSyncableService: InitializeWithService.";
     SyncStarted();
-    apps_builder_->InitializeWithService(this);
+    apps_builder_->InitializeWithService(this, model_.get());
   } else {
     VLOG(1) << this << ": AppListSyncableService: InitializeWithProfile.";
     apps_builder_->InitializeWithProfile(profile_, model_.get());
   }
 
   model_pref_updater_.reset(
       new ModelPrefUpdater(AppListPrefs::Get(profile_), model_.get()));
 
   if (app_list::switches::IsDriveAppsInAppListEnabled())
     drive_app_provider_.reset(new DriveAppProvider(profile_, this));
 }
 
+size_t AppListSyncableService::GetNumSyncItemsForTest() {
+  // If the model isn't built yet, there will be no sync items.
+  GetModel();
+
+  return sync_items_.size();
+}
+
 void AppListSyncableService::ResetDriveAppProviderForTest() {
   drive_app_provider_.reset();
 }
 
 void AppListSyncableService::Shutdown() {
   // DriveAppProvider touches other KeyedServices in its dtor and needs be
   // released in shutdown stage.
   drive_app_provider_.reset();
 }
 
@@ skipping 17 matching lines @@
   const std::string sync_id = GetDriveAppSyncId(drive_app_id);
   SyncItem* sync_item = FindSyncItem(sync_id);
   if (!sync_item)
     return;
 
   DCHECK_EQ(sync_item->item_type,
             sync_pb::AppListSpecifics::TYPE_REMOVE_DEFAULT_APP);
   DeleteSyncItem(sync_item);
 }
 
-void AppListSyncableService::Observe(
-    int type,
-    const content::NotificationSource& source,
-    const content::NotificationDetails& details) {
-  DCHECK_EQ(extensions::NOTIFICATION_EXTENSIONS_READY_DEPRECATED, type);
-  DCHECK_EQ(profile_, content::Source<Profile>(source).ptr());
-  registrar_.RemoveAll();
-  BuildModel();
-}
-
 const AppListSyncableService::SyncItem*
 AppListSyncableService::GetSyncItem(const std::string& id) const {
   SyncItemMap::const_iterator iter = sync_items_.find(id);
   if (iter != sync_items_.end())
     return iter->second;
   return NULL;
 }
 
 void AppListSyncableService::SetOemFolderName(const std::string& name) {
   oem_folder_name_ = name;
   AppListFolderItem* oem_folder = model_->FindFolderItem(kOemFolderId);
   if (oem_folder)
     model_->SetItemName(oem_folder, oem_folder_name_);
 }
 
+AppListModel* AppListSyncableService::GetModel() {
+  if (!apps_builder_)
+    BuildModel();
+
+  return model_.get();
+}
+
 void AppListSyncableService::AddItem(scoped_ptr<AppListItem> app_item) {
   SyncItem* sync_item = FindOrAddSyncItem(app_item.get());
   if (!sync_item)
     return;  // Item is not valid.
 
   std::string folder_id;
   if (app_list::switches::IsFolderUIEnabled()) {
     if (AppIsOem(app_item->id())) {
       folder_id = FindOrCreateOemFolder();
       VLOG_IF(2, !folder_id.empty())
@@ skipping 625 matching lines @@
   } else {
     res += " { " + item_name + " }";
     res += " [" + item_ordinal.ToDebugString() + "]";
     if (!parent_id.empty())
       res += " <" + parent_id.substr(0, 8) + ">";
   }
   return res;
 }
 
 }  // namespace app_list