arc: Temporary workaround for enabling ARC Kiosk on N.

chrome/browser/chromeos/arc/arc_util.cc

 // Copyright 2017 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/arc/arc_util.h"
 
 #include <linux/magic.h>
 #include <sys/statfs.h>
+#include <set>
 
 #include "base/callback.h"
 #include "base/files/file_path.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/sys_info.h"
 #include "base/task_scheduler/post_task.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/chromeos/arc/arc_session_manager.h"
 #include "chrome/browser/chromeos/login/user_flow.h"
 #include "chrome/browser/chromeos/login/users/chrome_user_manager.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
@@ skipping 10 matching lines @@
 constexpr char kLsbReleaseArcVersionKey[] = "CHROMEOS_ARC_ANDROID_SDK_VERSION";
 constexpr char kAndroidMSdkVersion[] = "23";
 
 // Let IsAllowedForProfile() return "false" for any profile.
 bool g_disallow_for_testing = false;
 
 // Let IsArcBlockedDueToIncompatibleFileSystem() return the specified value
 // during test runs.
 bool g_arc_blocked_due_to_incomaptible_filesystem_for_testing = false;
 
+// TODO(kinaba): Temporary workaround for crbug.com/729034.
+//
+// Some type of accounts don't have user prefs. As a short-term workaround,
+// store the compatibility info from them on memory, ignoring the defect that
+// it cannot survive browser crash and restart.
+//
+// This will be removed once the forced migration for ARC Kiosk user is
+// implemented. After it's done such types of accounts cannot even sign-in
+// with incompatible filesystem. Hence it'll be safe to always regard compatible
+// for them then.
+base::LazyInstance<std::set<AccountId>>::DestructorAtExit
+    g_known_compatible_users = LAZY_INSTANCE_INITIALIZER;
+
 // Returns whether ARC can run on the filesystem mounted at |path|.
 // This function should run only on threads where IO operations are allowed.
 bool IsArcCompatibleFilesystem(const base::FilePath& path) {
   base::ThreadRestrictions::AssertIOAllowed();
 
   // If it can be verified it is not on ecryptfs, then it is ok.
   struct statfs statfs_buf;
   if (statfs(path.value().c_str(), &statfs_buf) < 0)
     return false;
   return statfs_buf.f_type != ECRYPTFS_SUPER_MAGIC;
 }
 
+FileSystemCompatibilityState GetFileSystemCompatibilityPref(
+    const AccountId& account_id) {
+  int pref_value = kFileSystemIncompatible;
+  user_manager::known_user::GetIntegerPref(
+      account_id, prefs::kArcCompatibleFilesystemChosen, &pref_value);
+  return static_cast<FileSystemCompatibilityState>(pref_value);
+}
+
 // Stores the result of IsArcCompatibleFilesystem posted back from the blocking
 // task runner.
 void StoreCompatibilityCheckResult(const AccountId& account_id,
                                    const base::Closure& callback,
                                    bool is_compatible) {
   if (is_compatible) {
     user_manager::known_user::SetIntegerPref(
         account_id, prefs::kArcCompatibleFilesystemChosen,
         arc::kFileSystemCompatible);
+
+    // TODO(kinaba): Remove this code for accounts without user prefs.
+    // See the comment for |g_known_compatible_users| for the detail.
+    if (GetFileSystemCompatibilityPref(account_id) !=
+        arc::kFileSystemCompatible) {
+      g_known_compatible_users.Get().insert(account_id);
+    }
   }
   callback.Run();
 }
 
-FileSystemCompatibilityState GetFileSystemCompatibilityPref(
-    const AccountId& account_id) {
-  int pref_value = kFileSystemIncompatible;
-  user_manager::known_user::GetIntegerPref(
-      account_id, prefs::kArcCompatibleFilesystemChosen, &pref_value);
-  return static_cast<FileSystemCompatibilityState>(pref_value);
-}
-
 }  // namespace
 
 bool IsArcAllowedForProfile(const Profile* profile) {
   if (g_disallow_for_testing) {
     VLOG(1) << "ARC is disallowed for testing.";
     return false;
   }
 
   // ARC Kiosk can be enabled even if ARC is not yet supported on the device.
   // In that case IsArcKioskMode() should return true as profile is already
@@ skipping 68 matching lines @@
 
   // Returns false for profiles not associated with users (like sign-in profile)
   if (!user)
     return false;
 
   // chromeos::UserSessionManager does the actual file system check and stores
   // the result to prefs, so that it survives crash-restart.
   FileSystemCompatibilityState filesystem_compatibility =
       GetFileSystemCompatibilityPref(user->GetAccountId());
   const bool is_filesystem_compatible =
-      filesystem_compatibility != kFileSystemIncompatible;
+      filesystem_compatibility != kFileSystemIncompatible ||
+      g_known_compatible_users.Get().count(user->GetAccountId()) != 0;
   std::string arc_sdk_version;
   const bool is_M = base::SysInfo::GetLsbReleaseValue(kLsbReleaseArcVersionKey,
                                                       &arc_sdk_version) &&
                     arc_sdk_version == kAndroidMSdkVersion;
 
   // To run ARC we want to make sure either
   // - Underlying file system is compatible with ARC, or
   // - SDK version is M.
   if (!is_filesystem_compatible && !is_M) {
     VLOG(1)
@@ skipping 81 matching lines @@
   // Otherwise, check the underlying filesystem.
   base::PostTaskWithTraitsAndReplyWithResult(
       FROM_HERE,
       {base::MayBlock(), base::TaskPriority::USER_BLOCKING,
        base::TaskShutdownBehavior::CONTINUE_ON_SHUTDOWN},
       base::Bind(&IsArcCompatibleFilesystem, profile_path),
       base::Bind(&StoreCompatibilityCheckResult, account_id, callback));
 }
 
 }  // namespace arc