Create AppListSyncableService with BrowserContext

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 "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 205 matching lines @@
   // 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_);
   // TODO(stevenjb): Correctly handle OTR profiles for Guest mode.
   if (!profile_->IsOffTheRecord() && SyncAppListEnabled()) {
-    DVLOG(1) << this << ": AppListSyncableService: InitializeWithService.";
+    VLOG(1) << this << ": AppListSyncableService: InitializeWithService.";
     SyncStarted();
     apps_builder_->InitializeWithService(this);
   } else {
-    DVLOG(1) << this << ": AppListSyncableService: InitializeWithProfile.";
+    VLOG(1) << this << ": AppListSyncableService: InitializeWithProfile.";
     apps_builder_->InitializeWithProfile(profile_, model_.get());
   }
 }
 
 void AppListSyncableService::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK_EQ(chrome::NOTIFICATION_EXTENSIONS_READY, type);
   DCHECK_EQ(profile_, content::Source<Profile>(source).ptr());
@@ skipping 18 matching lines @@
 
 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();
-      DVLOG(1) << this << ": AddItem to OEM folder: " << sync_item->ToString();
+      VLOG(2) << this << ": AddItem to OEM folder: " << sync_item->ToString();
     } else {
       folder_id = sync_item->parent_id;
-      DVLOG(1) << this << ": AddItem: " << sync_item->ToString()
-               << " Folder: '" << folder_id << "'";
     }
   }
-  DVLOG(1) << this << ": AddItem: " << sync_item->ToString()
-           << "Folder: '" << folder_id << "'";
+  VLOG(2) << this << ": AddItem: " << sync_item->ToString()
+          << "Folder: '" << folder_id << "'";
   model_->AddItemToFolder(app_item.Pass(), folder_id);
 }
 
 AppListSyncableService::SyncItem* AppListSyncableService::FindOrAddSyncItem(
     AppListItem* app_item) {
   const std::string& item_id = app_item->id();
   if (item_id.empty()) {
     LOG(ERROR) << "AppListItem item with empty ID";
     return NULL;
   }
@@ skipping 38 matching lines @@
 
 bool AppListSyncableService::RemoveDefaultApp(AppListItem* item,
                                               SyncItem* sync_item) {
   CHECK_EQ(sync_item->item_type,
            sync_pb::AppListSpecifics::TYPE_REMOVE_DEFAULT_APP);
 
   // If there is an existing REMOVE_DEFAULT_APP entry, and the app is
   // installed as a Default app, uninstall the app instead of adding it.
   if (sync_item->item_type == sync_pb::AppListSpecifics::TYPE_APP &&
       AppIsDefault(extension_system_->extension_service(), item->id())) {
-    DVLOG(1) << this << ": HandleDefaultApp: Uninstall: "
-             << sync_item->ToString();
+    VLOG(2) << this << ": HandleDefaultApp: Uninstall: "
+            << sync_item->ToString();
     UninstallExtension(extension_system_->extension_service(), item->id());
     return true;
   }
 
   // Otherwise, we are adding the app as a non-default app (i.e. an app that
   // was installed by Default and removed is getting installed explicitly by
   // the user), so delete the REMOVE_DEFAULT_APP.
   DeleteSyncItem(sync_item);
   return false;
 }
@@ skipping 36 matching lines @@
   if (!app_list::switches::IsFolderUIEnabled())
     return;
   bool is_oem = AppIsOem(app_item->id());
   if (!is_oem && app_item->folder_id() == kOemFolderId)
     model_->MoveItemToFolder(app_item, "");
   else if (is_oem && app_item->folder_id() != kOemFolderId)
     model_->MoveItemToFolder(app_item, kOemFolderId);
 }
 
 void AppListSyncableService::RemoveSyncItem(const std::string& id) {
-  DVLOG(2) << this << ": RemoveSyncItem: " << id.substr(0, 8);
+  VLOG(2) << this << ": RemoveSyncItem: " << id.substr(0, 8);
   SyncItemMap::iterator iter = sync_items_.find(id);
   if (iter == sync_items_.end()) {
     DVLOG(2) << this << " : RemoveSyncItem: No Item.";
     return;
   }
 
   // Check for existing RemoveDefault sync item.
   SyncItem* sync_item = iter->second;
   sync_pb::AppListSpecifics::AppListItemType type = sync_item->item_type;
   if (type == sync_pb::AppListSpecifics::TYPE_REMOVE_DEFAULT_APP) {
@@ skipping 64 matching lines @@
     scoped_ptr<syncer::SyncErrorFactory> error_handler) {
   DCHECK(!sync_processor_.get());
   DCHECK(sync_processor.get());
   DCHECK(error_handler.get());
 
   sync_processor_ = sync_processor.Pass();
   sync_error_handler_ = error_handler.Pass();
 
   syncer::SyncMergeResult result = syncer::SyncMergeResult(type);
   result.set_num_items_before_association(sync_items_.size());
-  DVLOG(1) << this << ": MergeDataAndStartSyncing: "
-           << initial_sync_data.size();
+  VLOG(1) << this << ": MergeDataAndStartSyncing: "
+          << initial_sync_data.size();
 
   // Copy all sync items to |unsynced_items|.
   std::set<std::string> unsynced_items;
   for (SyncItemMap::const_iterator iter = sync_items_.begin();
        iter != sync_items_.end(); ++iter) {
     unsynced_items.insert(iter->first);
   }
 
   // Create SyncItem entries for initial_sync_data.
   size_t new_items = 0, updated_items = 0;
@@ skipping 46 matching lines @@
   DCHECK_EQ(type, syncer::APP_LIST);
 
   sync_processor_.reset();
   sync_error_handler_.reset();
 }
 
 syncer::SyncDataList AppListSyncableService::GetAllSyncData(
     syncer::ModelType type) const {
   DCHECK_EQ(syncer::APP_LIST, type);
 
-  DVLOG(1) << this << ": GetAllSyncData: " << sync_items_.size();
+  VLOG(1) << this << ": GetAllSyncData: " << sync_items_.size();
   syncer::SyncDataList list;
   for (SyncItemMap::const_iterator iter = sync_items_.begin();
        iter != sync_items_.end(); ++iter) {
     DVLOG(2) << this << " -> SYNC: " << iter->second->ToString();
     list.push_back(GetSyncDataFromSyncItem(iter->second));
   }
   return list;
 }
 
 syncer::SyncError AppListSyncableService::ProcessSyncChanges(
     const tracked_objects::Location& from_here,
     const syncer::SyncChangeList& change_list) {
   if (!sync_processor_.get()) {
     return syncer::SyncError(FROM_HERE,
                              syncer::SyncError::DATATYPE_ERROR,
                              "App List syncable service is not started.",
                              syncer::APP_LIST);
   }
 
   // Don't observe the model while processing incoming sync changes.
   model_observer_.reset();
 
-  DVLOG(1) << this << ": ProcessSyncChanges: " << change_list.size();
+  VLOG(1) << this << ": ProcessSyncChanges: " << change_list.size();
   for (syncer::SyncChangeList::const_iterator iter = change_list.begin();
        iter != change_list.end(); ++iter) {
     const SyncChange& change = *iter;
     DVLOG(2) << this << "  Change: "
              << change.sync_data().GetSpecifics().app_list().item_id()
              << " (" << change.change_type() << ")";
     if (change.change_type() == SyncChange::ACTION_ADD ||
         change.change_type() == SyncChange::ACTION_UPDATE) {
       ProcessSyncItemSpecifics(change.sync_data().GetSpecifics().app_list());
     } else if (change.change_type() == SyncChange::ACTION_DELETE) {
@@ skipping 44 matching lines @@
   }
 
   sync_item = CreateSyncItem(item_id, specifics.item_type());
   UpdateSyncItemFromSync(specifics, sync_item);
   ProcessNewSyncItem(sync_item);
   DVLOG(2) << this << " <- SYNC ADD: " << sync_item->ToString();
   return true;
 }
 
 void AppListSyncableService::ProcessNewSyncItem(SyncItem* sync_item) {
-  DVLOG(2) << "ProcessNewSyncItem: " << sync_item->ToString();
+  VLOG(2) << "ProcessNewSyncItem: " << sync_item->ToString();
   switch (sync_item->item_type) {
     case sync_pb::AppListSpecifics::TYPE_APP: {
       // New apps are added through ExtensionAppModelBuilder.
       // TODO(stevenjb): Determine how to handle app items in sync that
       // are not installed (e.g. default / OEM apps).
       return;
     }
     case sync_pb::AppListSpecifics::TYPE_REMOVE_DEFAULT_APP: {
-      DVLOG(1) << this << ": Uninstall: " << sync_item->ToString();
+      VLOG(1) << this << ": Uninstall: " << sync_item->ToString();
       UninstallExtension(extension_system_->extension_service(),
                          sync_item->item_id);
       return;
     }
     case sync_pb::AppListSpecifics::TYPE_FOLDER: {
       AppListItem* app_item = model_->FindItem(sync_item->item_id);
       if (!app_item)
         return;  // Don't create new folders here, the model will do that.
       UpdateAppItemFromSyncItem(sync_item, app_item);
       return;
     }
     case sync_pb::AppListSpecifics::TYPE_URL: {
       // TODO(stevenjb): Implement
       LOG(WARNING) << "TYPE_URL not supported";
       return;
     }
   }
   NOTREACHED() << "Unrecognized sync item type: " << sync_item->ToString();
 }
 
 void AppListSyncableService::ProcessExistingSyncItem(SyncItem* sync_item) {
   if (sync_item->item_type ==
       sync_pb::AppListSpecifics::TYPE_REMOVE_DEFAULT_APP) {
     return;
   }
-  DVLOG(2) << "ProcessExistingSyncItem: " << sync_item->ToString();
+  VLOG(2) << "ProcessExistingSyncItem: " << sync_item->ToString();
   AppListItem* app_item = model_->FindItem(sync_item->item_id);
   DVLOG(2) << " AppItem: " << app_item->ToDebugString();
   if (!app_item) {
     LOG(ERROR) << "Item not found in model: " << sync_item->ToString();
     return;
   }
   // This is the only place where sync can cause an item to change folders.
   if (app_list::switches::IsFolderUIEnabled() &&
       app_item->folder_id() != sync_item->parent_id &&
       !AppIsOem(app_item->id())) {
@@ skipping 14 matching lines @@
       (app_item->GetItemType() == AppListFolderItem::kItemType ||
        app_item->name().empty())) {
     model_->SetItemName(app_item, sync_item->item_name);
   }
 }
 
 bool AppListSyncableService::SyncStarted() {
   if (sync_processor_.get())
     return true;
   if (flare_.is_null()) {
-    DVLOG(2) << this << ": SyncStarted: Flare.";
+    VLOG(1) << this << ": SyncStarted: Flare.";
     flare_ = sync_start_util::GetFlareForSyncableService(profile_->GetPath());
     flare_.Run(syncer::APP_LIST);
   }
   return false;
 }
 
 void AppListSyncableService::SendSyncChange(
     SyncItem* sync_item,
     SyncChange::SyncChangeType sync_change_type) {
   if (!SyncStarted()) {
@@ skipping 29 matching lines @@
   return sync_item;
 }
 
 void AppListSyncableService::DeleteSyncItemSpecifics(
     const sync_pb::AppListSpecifics& specifics) {
   const std::string& item_id = specifics.item_id();
   if (item_id.empty()) {
     LOG(ERROR) << "Delete AppList item with empty ID";
     return;
   }
-  DVLOG(2) << this << ": DeleteSyncItemSpecifics: " << item_id.substr(0, 8);
+  VLOG(2) << this << ": DeleteSyncItemSpecifics: " << item_id.substr(0, 8);
   SyncItemMap::iterator iter = sync_items_.find(item_id);
   if (iter == sync_items_.end())
     return;
   sync_pb::AppListSpecifics::AppListItemType item_type =
       iter->second->item_type;
   DVLOG(2) << this << " <- SYNC DELETE: " << iter->second->ToString();
   delete iter->second;
   sync_items_.erase(iter);
   // Only delete apps from the model. Folders will be deleted when all
   // children have been deleted.
@@ skipping 28 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