[cros] Add --stub-cros-settings option for testing.

chrome/browser/chromeos/login/ownership_service.cc

 // Copyright (c) 2011 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/ownership_service.h"
 
+#include "base/command_line.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/lazy_instance.h"
 #include "base/synchronization/lock.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/common/chrome_notification_types.h"
+#include "chrome/common/chrome_switches.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_service.h"
 
 using content::BrowserThread;
 
 namespace chromeos {
 
 static base::LazyInstance<OwnershipService> g_ownership_service =
     LAZY_INSTANCE_INITIALIZER;
 
 //  static
 OwnershipService* OwnershipService::GetSharedInstance() {
   return g_ownership_service.Pointer();
 }
 
 OwnershipService::OwnershipService()
     : manager_(new OwnerManager),
       utils_(OwnerKeyUtils::Create()),
-      ownership_status_(OWNERSHIP_UNKNOWN) {
+      ownership_status_(OWNERSHIP_UNKNOWN),
+      force_ownership_(CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kStubCrosSettings)) {
   notification_registrar_.Add(
       this,
       chrome::NOTIFICATION_OWNER_KEY_FETCH_ATTEMPT_SUCCEEDED,
       content::NotificationService::AllSources());
 }
 
 OwnershipService::~OwnershipService() {}
 
 void OwnershipService::Prewarm() {
   // Note that we cannot prewarm in constructor because in current codebase
@@ skipping 10 matching lines @@
     // DISABLE_RUNNABLE_METHOD_REFCOUNT.  So avoid posting task in those
     // circumstances in order to avoid accessing already deleted object.
   }
 }
 
 bool OwnershipService::IsAlreadyOwned() {
   return file_util::PathExists(utils_->GetOwnerKeyFilePath());
 }
 
 OwnershipService::Status OwnershipService::GetStatus(bool blocking) {
+  if (force_ownership_)
+    return OWNERSHIP_TAKEN;
   Status status = OWNERSHIP_UNKNOWN;
   bool is_owned = false;
   if (BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     ownership_status_lock_.Acquire();
     status = ownership_status_;
     ownership_status_lock_.Release();
     if (status != OWNERSHIP_UNKNOWN || !blocking)
       return status;
     // Under common usage there is very short lapse of time when ownership
     // status is still unknown after constructing OwnershipService.
@@ skipping 57 matching lines @@
                                const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_OWNER_KEY_FETCH_ATTEMPT_SUCCEEDED) {
     SetStatus(OWNERSHIP_TAKEN);
     notification_registrar_.RemoveAll();
   } else {
     NOTREACHED();
   }
 }
 
 bool OwnershipService::CurrentUserIsOwner() {
+  if (force_ownership_)
+    return true;
   // If this user has the private key associated with the owner's
   // public key, this user is the owner.
   return IsAlreadyOwned() && manager_->EnsurePrivateKey();
 }
 
 // static
 void OwnershipService::UpdateOwnerKey(OwnershipService* service,
                                       const BrowserThread::ID thread_id,
                                       const std::vector<uint8>& new_key,
                                       OwnerManager::KeyUpdateDelegate* d) {
@@ skipping 55 matching lines @@
   SetStatus(status);
 }
 
 void OwnershipService::SetStatus(Status new_status) {
   DCHECK(new_status == OWNERSHIP_TAKEN || new_status == OWNERSHIP_NONE);
   base::AutoLock lk(ownership_status_lock_);
   ownership_status_ = new_status;
 }
 
 }  // namespace chromeos