Create LoadProfile method in profile_manager

chrome/browser/notifications/platform_notification_service_impl.cc

 // Copyright 2014 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/notifications/platform_notification_service_impl.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 83 matching lines @@
       ->GetNotificationUIManager()->CancelById(id, profile_id);
 }
 
 // Callback to run once the profile has been loaded in order to perform a
 // given |operation| in a notification.
 void ProfileLoadedCallback(
     PlatformNotificationServiceImpl::NotificationOperation operation,
     const GURL& origin,
     int64_t persistent_notification_id,
     int action_index,
-    bool incognito,
-    Profile* profile,
-    Profile::CreateStatus status) {
-  if (status == Profile::CREATE_STATUS_CREATED) {
-    // This is an intermediate state, we will be also called
-    // again with CREATE_STATUS_INITIALIZED once everything is ready
-    // so ignore it.
+    Profile* profile) {
+  if (!profile)

[Peter Beverloo, 2016/03/11 17:45:15]

We should probably log something if the profile could not be loaded? Maybe we
should have define a new content::PersistentNotificationStatus for this
(PERSISTENT_NOTIFICATION_STATUS_INVALID_PROFILE?)

[Miguel Garcia, 2016/03/14 18:29:00]

Will add a TODO to add the state and UMA to it and add logging for now.

     return;
-  }
-  if (status != Profile::CREATE_STATUS_INITIALIZED) {
-    LOG(WARNING) << "Profile not loaded correctly";
-    return;
-  }
-  DCHECK(profile);
-  profile = incognito ? profile->GetOffTheRecordProfile() : profile;
 
   switch (operation) {
     case PlatformNotificationServiceImpl::NOTIFICATION_CLICK:
       PlatformNotificationServiceImpl::GetInstance()
           ->OnPersistentNotificationClick(profile, persistent_notification_id,
                                           origin, action_index);
       break;
     case PlatformNotificationServiceImpl::NOTIFICATION_CLOSE:
       PlatformNotificationServiceImpl::GetInstance()
           ->OnPersistentNotificationClose(profile, persistent_notification_id,
@@ skipping 24 matching lines @@
 void PlatformNotificationServiceImpl::ProcessPersistentNotificationOperation(
     NotificationOperation operation,
     const std::string& profile_id,
     bool incognito,
     const GURL& origin,
     int64_t persistent_notification_id,
     int action_index) {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   DCHECK(profile_manager);
 
-  // ProfileManager does not offer a good interface to load a profile or
-  // fail. Instead it offers a method to create the profile and simply load it
-  // if it already exist. We therefore check first that the profile is there
-  // and fail early otherwise.
-  const base::FilePath profile_path =
-      profile_manager->user_data_dir().AppendASCII(profile_id);
-
-  ProfileAttributesEntry* entry = nullptr;
-  if (!profile_manager->GetProfileAttributesStorage().
-      GetProfileAttributesWithPath(profile_path, &entry)) {
-    LOG(ERROR) << "Loading a path that does not exist";
-    return;
-  }
-
-  profile_manager->CreateProfileAsync(
-      profile_path,
+  profile_manager->LoadProfile(
+      profile_id, incognito,
       base::Bind(&ProfileLoadedCallback, operation, origin,
-                 persistent_notification_id, action_index, incognito),
-      base::string16(), std::string(), std::string());
+                 persistent_notification_id, action_index));
 }
 
 void PlatformNotificationServiceImpl::OnPersistentNotificationClick(
     BrowserContext* browser_context,
     int64_t persistent_notification_id,
     const GURL& origin,
     int action_index) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   blink::WebNotificationPermission permission =
       CheckPermissionOnUIThread(browser_context, origin,
@@ skipping 363 matching lines @@
         extensions::ExtensionRegistry::Get(profile)->GetExtensionById(
             origin.host(), extensions::ExtensionRegistry::EVERYTHING);
     DCHECK(extension);
 
     return base::UTF8ToUTF16(extension->name());
   }
 #endif
 
   return base::string16();
 }