arc: Implement safe access to ArcAuthService.

chrome/browser/chromeos/arc/arc_support_host.cc

 // Copyright 2016 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_support_host.h"
 
 #include <string>
 
 #include "ash/common/system/chromeos/devicetype_utils.h"
 #include "base/i18n/timezone.h"
@@ skipping 56 matching lines @@
     "chrome-extension://cnbgggchhmkkdmeppjobngjoejnihlei/"};
 
 // static
 std::unique_ptr<extensions::NativeMessageHost> ArcSupportHost::Create() {
   return std::unique_ptr<NativeMessageHost>(new ArcSupportHost());
 }
 
 ArcSupportHost::ArcSupportHost() {
   arc::ArcAuthService* arc_auth_service = arc::ArcAuthService::Get();
   DCHECK(arc_auth_service);
+
+  if (!arc_auth_service->IsAllowed())
+    return;
+
   arc_auth_service->AddObserver(this);
   display::Screen::GetScreen()->AddObserver(this);
 
   pref_change_registrar_.Init(g_browser_process->local_state());
   pref_change_registrar_.Add(
       metrics::prefs::kMetricsReportingEnabled,
       base::Bind(&ArcSupportHost::OnMetricsPreferenceChanged,
                  base::Unretained(this)));
 }
 
 ArcSupportHost::~ArcSupportHost() {
   display::Screen::GetScreen()->RemoveObserver(this);
   arc::ArcAuthService* arc_auth_service = arc::ArcAuthService::Get();
   if (arc_auth_service)
     arc_auth_service->RemoveObserver(this);
 }
 
 void ArcSupportHost::Start(Client* client) {
   DCHECK(!client_);
   client_ = client;
 
-  Initialize();
+  if (!Initialize()) {
+    OnOptInUIClose();
+    return;
+  }
+
   SendMetricsMode();
 
   arc::ArcAuthService* arc_auth_service = arc::ArcAuthService::Get();
   DCHECK(arc_auth_service);
   OnOptInUIShowPage(arc_auth_service->ui_page(),
                     arc_auth_service->ui_page_status());
 }
 
-void ArcSupportHost::Initialize() {
+bool ArcSupportHost::Initialize() {
   DCHECK(client_);
+  arc::ArcAuthService* arc_auth_service = arc::ArcAuthService::Get();
+  if (!arc_auth_service->IsAllowed())
+    return false;
+
   std::unique_ptr<base::DictionaryValue> loadtime_data(
       new base::DictionaryValue());
   base::string16 device_name = ash::GetChromeOSDeviceName();
   loadtime_data->SetString(
       "greetingHeader",
       l10n_util::GetStringFUTF16(IDS_ARC_OPT_IN_DIALOG_HEADER, device_name));
   loadtime_data->SetString("greetingDescription",
                            l10n_util::GetStringFUTF16(
                                IDS_ARC_OPT_IN_DIALOG_DESCRIPTION, device_name));
   loadtime_data->SetString(
@@ skipping 24 matching lines @@
       "textBackupRestore",
       l10n_util::GetStringUTF16(IDS_ARC_OPT_IN_DIALOG_BACKUP_RESTORE));
   loadtime_data->SetString(
       "serverError",
       l10n_util::GetStringUTF16(IDS_ARC_SERVER_COMMUNICATION_ERROR));
 
   const std::string& app_locale = g_browser_process->GetApplicationLocale();
   const std::string& country_code = base::CountryCodeForCurrentTimezone();
   loadtime_data->SetString("countryCode", country_code);
 
-  arc::ArcAuthService* arc_auth_service = arc::ArcAuthService::Get();
-
   loadtime_data->SetBoolean(kBackupRestoreEnabled,
                             arc_auth_service->profile()->GetPrefs()->GetBoolean(
                                 prefs::kArcBackupRestoreEnabled));
 
   webui::SetLoadTimeDataDefaults(app_locale, loadtime_data.get());
   DCHECK(arc_auth_service);
   const std::string device_id = user_manager::known_user::GetDeviceId(
       multi_user_util::GetAccountIdFromProfile(arc_auth_service->profile()));
   DCHECK(!device_id.empty());
 
   base::DictionaryValue request;
   std::string request_string;
   request.SetString(kAction, kActionInitialize);
   request.Set(kData, std::move(loadtime_data));
   request.SetString(kDeviceId, device_id);
   base::JSONWriter::Write(request, &request_string);
   client_->PostMessageFromNativeHost(request_string);
+
+  return true;
 }
 
 void ArcSupportHost::OnDisplayAdded(const display::Display& new_display) {}
 
 void ArcSupportHost::OnDisplayRemoved(const display::Display& old_display) {}
 
 void ArcSupportHost::OnDisplayMetricsChanged(const display::Display& display,
                                              uint32_t changed_metrics) {
   base::DictionaryValue request;
   std::string request_string;
   request.SetString(kAction, kActionSetWindowBounds);
   base::JSONWriter::Write(request, &request_string);
   client_->PostMessageFromNativeHost(request_string);
 }
 
 void ArcSupportHost::OnMetricsPreferenceChanged() {
   SendMetricsMode();
 }
 
 void ArcSupportHost::SendMetricsMode() {
   arc::ArcAuthService* arc_auth_service = arc::ArcAuthService::Get();
-  DCHECK(arc_auth_service);
+  DCHECK(arc_auth_service && arc_auth_service->IsAllowed());
   const Profile* profile = arc_auth_service->profile();
 
   const bool metrics_managed = IsMetricsReportingPolicyManaged();
   const bool owner_profile =
       profile && chromeos::ProfileHelper::IsOwnerProfile(profile);
   const bool metrics_on =
       ChromeMetricsServiceAccessor::IsMetricsAndCrashReportingEnabled();
 
   int message_id;
   if (metrics_managed || !owner_profile) {
@@ skipping 38 matching lines @@
   std::string response_string;
   base::JSONWriter::Write(response, &response_string);
   client_->PostMessageFromNativeHost(response_string);
 }
 
 void ArcSupportHost::EnableMetrics(bool is_enabled) {
   InitiateMetricsReportingChange(is_enabled, OnMetricsReportingCallbackType());
 }
 
 void ArcSupportHost::EnableBackupRestore(bool is_enabled) {
-  PrefService* pref_service = arc::ArcAuthService::Get()->profile()->GetPrefs();
+  arc::ArcAuthService* arc_auth_service = arc::ArcAuthService::Get();
+  DCHECK(arc_auth_service && arc_auth_service->IsAllowed());
+  PrefService* pref_service = arc_auth_service->profile()->GetPrefs();
   pref_service->SetBoolean(prefs::kArcBackupRestoreEnabled, is_enabled);
 }
 
 void ArcSupportHost::OnMessage(const std::string& request_string) {
   std::unique_ptr<base::Value> request_value =
       base::JSONReader::Read(request_string);
   base::DictionaryValue* request;
   if (!request_value || !request_value->GetAsDictionary(&request)) {
     NOTREACHED();
     return;
@@ skipping 37 matching lines @@
     EnableBackupRestore(is_enabled);
   } else {
     NOTREACHED();
   }
 }
 
 scoped_refptr<base::SingleThreadTaskRunner> ArcSupportHost::task_runner()
     const {
   return base::ThreadTaskRunnerHandle::Get();
 }