Use only IJG decoding path to decode profile pictures on login screen

chrome/browser/chromeos/login/user_image_manager_impl.cc

 // Copyright (c) 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/chromeos/login/user_image_manager_impl.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
@@ skipping 220 matching lines @@
         // download will be scheduled for |kProfileDataDownloadDelayMs|
         // after user logs in).
         DCHECK(!image_path.empty() || image_index == User::kProfileImageIndex);
         std::string image_url;
         image_properties->GetString(kImageURLNodeName, &image_url);
         GURL image_gurl(image_url);
         // Until image has been loaded, use the stub image (gray avatar).
         user->SetStubImage(image_index, true);
         user->SetImageURL(image_gurl);
         if (!image_path.empty()) {
-          // Load user image asynchronously.
-          UserImageLoader* loader =
-              safe_source ? image_loader_.get() : unsafe_image_loader_.get();
-          loader->Start(
+          if (needs_migration) {
+            // Non-JPG image will be migrated once user logs in.
+            // Stub image will be used for now.
+            return;
+          }
+          DCHECK(safe_source);
+          if (!safe_source)
+            return;
+
+          // Load user image asynchronously - at this point we are able to use
+          // JPEG image loaded since image comes from safe pref source
+          // i.e. converted to JPEG.
+          image_loader_->Start(
               image_path, 0  /* no resize */,
               base::Bind(&UserImageManagerImpl::SetUserImage,
                          base::Unretained(this),
                          user->email(), image_index, image_gurl));
         }
       } else {
         NOTREACHED();
       }
     }
   }
 }
 
 void UserImageManagerImpl::UserLoggedIn(const std::string& email,
                                         bool user_is_new,
                                         bool user_is_local) {
   if (user_is_new) {
     SetInitialUserImage(email);
   } else {
-    int image_index = UserManager::Get()->GetLoggedInUser()->image_index();
+    User* user = UserManager::Get()->GetLoggedInUser();
 
     if (!user_is_local) {
       // If current user image is profile image, it needs to be refreshed.
-      bool download_profile_image = image_index == User::kProfileImageIndex;
+      bool download_profile_image =
+          user->image_index() == User::kProfileImageIndex;
       if (download_profile_image)
         InitDownloadedProfileImage();
 
       // Download user's profile data (full name and optionally image) to see if
       // it has changed.
       BrowserThread::PostDelayedTask(
           BrowserThread::UI,
           FROM_HERE,
           base::Bind(&UserImageManagerImpl::DownloadProfileData,
                      base::Unretained(this),
                      kProfileDownloadReasonLoggedIn,
                      download_profile_image),
           base::TimeDelta::FromSeconds(kProfileDataDownloadDelaySec));
     }
 
     UMA_HISTOGRAM_ENUMERATION("UserImage.LoggedIn",
-                              ImageIndexToHistogramIndex(image_index),
+                              ImageIndexToHistogramIndex(user->image_index()),
                               kHistogramImagesCount);
 
     if (users_to_migrate_.count(email)) {
-      // User needs image format migration.
-      BrowserThread::PostDelayedTask(
-          BrowserThread::UI,
-          FROM_HERE,
-          base::Bind(&UserImageManagerImpl::MigrateUserImage,
-                     base::Unretained(this)),
-          base::TimeDelta::FromSeconds(user_image_migration_delay_sec));
+      const DictionaryValue* prefs_images_unsafe =
+          g_browser_process->local_state()->GetDictionary(kUserImages);
+      const base::DictionaryValue* image_properties = NULL;
+      if (prefs_images_unsafe->GetDictionaryWithoutPathExpansion(
+              user->email(), &image_properties)) {
+        std::string image_path;
+        image_properties->GetString(kImagePathNodeName, &image_path);
+        if (!image_path.empty()) {
+          // User needs image format migration but
+          // first we need to load and decode that image.
+          LOG(INFO) << "Waiting for user image to load before migration";
+          migrate_current_user_on_load_ = true;
+              unsafe_image_loader_->Start(
+                  image_path, 0  /* no resize */,
+                  base::Bind(&UserImageManagerImpl::SetUserImage,
+                             base::Unretained(this),
+                             user->email(),
+                             user->image_index(),
+                             user->image_url()));
+        } else {
+          // Otherwise migrate user image properties right away.
+          BrowserThread::PostDelayedTask(
+              BrowserThread::UI,
+              FROM_HERE,
+              base::Bind(&UserImageManagerImpl::MigrateUserImage,
+                         base::Unretained(this)),
+              base::TimeDelta::FromSeconds(user_image_migration_delay_sec));
+        }
+      }
     }
   }
 
   if (!user_is_local) {
     // Set up a repeating timer for refreshing the profile data.
     profile_download_timer_.Start(
         FROM_HERE, base::TimeDelta::FromSeconds(kProfileRefreshIntervalSec),
         this, &UserImageManagerImpl::DownloadProfileDataScheduled);
   }
 }
@@ skipping 436 matching lines @@
   if (prefs_images_update->GetDictionaryWithoutPathExpansion(
           username, &image_properties)) {
     std::string image_path;
     image_properties->GetString(kImagePathNodeName, &image_path);
     prefs_images_update->RemoveWithoutPathExpansion(username, NULL);
     DeleteImageFile(image_path);
   }
 }
 
 }  // namespace chromeos