Use stub impl when libcros fails to load

chrome/browser/chromeos/cros/login_library.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/cros/login_library.h"
 
 #include "base/message_loop.h"
 #include "base/task.h"
 #include "base/timer.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/cros/cros_library.h"
 #include "chrome/browser/chromeos/login/signed_settings.h"
 #include "chrome/browser/chromeos/login/signed_settings_temp_storage.h"
 #include "chrome/browser/policy/proto/device_management_backend.pb.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/browser/browser_thread.h"
 #include "content/common/notification_service.h"
 
 namespace em = enterprise_management;
 namespace chromeos {
 
 LoginLibrary::~LoginLibrary() {}
 
 class LoginLibraryImpl : public LoginLibrary {
  public:
   LoginLibraryImpl() : job_restart_request_(NULL) {
-    CHECK(CrosLibrary::Get() && CrosLibrary::Get()->libcros_loaded());
-    Init();
   }
 
   virtual ~LoginLibraryImpl() {
     if (session_connection_) {
       DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
       chromeos::DisconnectSession(session_connection_);
     }
   }
 
-  void EmitLoginPromptReady() {
+  virtual void Init() OVERRIDE {
+    DCHECK(CrosLibrary::Get()->libcros_loaded());
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    session_connection_ = chromeos::MonitorSession(&Handler, this);
+  }
+
+  virtual void EmitLoginPromptReady() OVERRIDE {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     chromeos::EmitLoginPromptReady();
   }
 
-  void RequestRetrievePolicy(RetrievePolicyCallback callback, void* delegate) {
+  virtual void RequestRetrievePolicy(
+      RetrievePolicyCallback callback, void* delegate) OVERRIDE {
     DCHECK(callback) << "must provide a callback to RequestRetrievePolicy()";
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     chromeos::RetrievePolicy(callback, delegate);
   }
 
-  void RequestStorePolicy(const std::string& policy,
-                          StorePolicyCallback callback,
-                          void* delegate) {
+  virtual void RequestStorePolicy(const std::string& policy,
+                                  StorePolicyCallback callback,
+                                  void* delegate) OVERRIDE {
     DCHECK(callback) << "must provide a callback to StorePolicy()";
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     chromeos::StorePolicy(policy.c_str(), policy.length(), callback, delegate);
   }
 
-  bool StartSession(const std::string& user_email,
-                    const std::string& unique_id /* unused */) {
+  virtual bool StartSession(
+      const std::string& user_email,
+      const std::string& unique_id /* unused */) OVERRIDE {
     // only pass unique_id through once we use it for something.
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     return chromeos::StartSession(user_email.c_str(), "");
   }
 
-  bool StopSession(const std::string& unique_id /* unused */) {
+  virtual bool StopSession(const std::string& unique_id /* unused */) OVERRIDE {
     // only pass unique_id through once we use it for something.
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     return chromeos::StopSession("");
   }
 
-  bool RestartEntd() {
+  virtual bool RestartEntd() OVERRIDE {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     return chromeos::RestartEntd();
   }
 
-  bool RestartJob(int pid, const std::string& command_line) {
+  virtual bool RestartJob(int pid, const std::string& command_line) OVERRIDE {
     if (job_restart_request_) {
       NOTREACHED();
       return false;
     }
     job_restart_request_ = new JobRestartRequest(pid, command_line);
     return true;
   }
 
  private:
   class JobRestartRequest
@@ skipping 78 matching lines @@
         break;
       case PropertyOpFailure:
         self->CompletePropertyOp(false);
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
-  void Init() {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-    session_connection_ = chromeos::MonitorSession(&Handler, this);
-  }
-
   void CompleteSetOwnerKey(bool value) {
     VLOG(1) << "Owner key generation: " << (value ? "success" : "fail");
     int result =
         chrome::NOTIFICATION_OWNER_KEY_FETCH_ATTEMPT_SUCCEEDED;
     if (!value)
       result = chrome::NOTIFICATION_OWNER_KEY_FETCH_ATTEMPT_FAILED;
 
     // Whether we exported the public key or not, send a notification indicating
     // that we're done with this attempt.
     NotificationService::current()->Notify(result,
@@ skipping 24 matching lines @@
   JobRestartRequest* job_restart_request_;
 
   DISALLOW_COPY_AND_ASSIGN(LoginLibraryImpl);
 };
 
 class LoginLibraryStubImpl : public LoginLibrary {
  public:
   LoginLibraryStubImpl() {}
   virtual ~LoginLibraryStubImpl() {}
 
-  void EmitLoginPromptReady() { }
-  void RequestRetrievePolicy(RetrievePolicyCallback callback, void* delegate) {
+  virtual void Init() OVERRIDE {}
+
+  virtual void EmitLoginPromptReady() OVERRIDE {}
+  virtual void RequestRetrievePolicy(
+      RetrievePolicyCallback callback, void* delegate) OVERRIDE {
     callback(delegate, "", 0);
   }
-  void RequestStorePolicy(const std::string& policy,
-                          StorePolicyCallback callback,
-                          void* delegate) {
+  virtual void RequestStorePolicy(const std::string& policy,
+                                  StorePolicyCallback callback,
+                                  void* delegate) OVERRIDE {
     callback(delegate, true);
   }
-  bool StartSession(const std::string& user_email,
-                    const std::string& unique_id /* unused */) { return true; }
-  bool StopSession(const std::string& unique_id /* unused */) { return true; }
-  bool RestartJob(int pid, const std::string& command_line) { return true; }
-  bool RestartEntd() { return true; }
+  virtual bool StartSession(
+      const std::string& user_email,
+      const std::string& unique_id /* unused */) OVERRIDE {
+    return true;
+  }
+  virtual bool StopSession(const std::string& unique_id /* unused */) OVERRIDE {
+    return true;
+  }
+  virtual bool RestartJob(int pid, const std::string& command_line) OVERRIDE {
+    return true;
+  }
+  virtual bool RestartEntd() OVERRIDE { return true; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(LoginLibraryStubImpl);
 };
 
 // static
 LoginLibrary* LoginLibrary::GetImpl(bool stub) {
+  LoginLibrary* impl;
   if (stub)
-    return new LoginLibraryStubImpl();
+    impl = new LoginLibraryStubImpl();
   else
-    return new LoginLibraryImpl();
+    impl = new LoginLibraryImpl();
+  impl->Init();
+  return impl;
 }
 
 }  // namespace chromeos
-
-// Needed for NewRunnableMethod() call above.
-DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::LoginLibraryImpl);