Support chrome_to_mobile job receiving

chrome/browser/chrome_to_mobile/receive/chrome_to_mobile_receive_service_unittest.cc

Index: chrome/browser/chrome_to_mobile/receive/chrome_to_mobile_receive_service_unittest.cc
diff --git a/chrome/browser/chrome_to_mobile/receive/chrome_to_mobile_receive_service_unittest.cc b/chrome/browser/chrome_to_mobile/receive/chrome_to_mobile_receive_service_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..64327e5473922ba15330604c8f8370b3822f3e74
--- /dev/null
+++ b/chrome/browser/chrome_to_mobile/receive/chrome_to_mobile_receive_service_unittest.cc
@@ -0,0 +1,845 @@
+// Copyright 2012 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 <string>
+#include <vector>
+
+#include "base/message_loop.h"
+#include "base/threading/thread.h"
+#include "chrome/browser/chrome_to_mobile/receive/chrome_to_mobile_receive_service.h"
+#include "chrome/browser/chrome_to_mobile/receive/chrome_to_mobile_receive_backend.h"
+#include "chrome/browser/chrome_to_mobile/receive/chrome_to_mobile_receiving_device_info_handler.h"
+#include "chrome/browser/signin/signin_manager.h"
+#include "chrome/browser/signin/signin_manager_fake.h"
+#include "chrome/browser/signin/token_service.h"
+#include "chrome/browser/signin/token_service_factory.h"
+#include "chrome/browser/prefs/pref_service.h"
+#include "chrome/common/chrome_notification_types.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/test/base/testing_profile.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/test/test_browser_thread.h"
+#include "google_apis/gaia/gaia_auth_consumer.h"
+#include "google_apis/gaia/gaia_constants.h"
+#include "net/url_request/url_request_test_util.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "testing/platform_test.h"
+
+using namespace chrome_to_mobile_receive;
+
+namespace {
+
+class TestChromeToMobileReceiveBackend : public ChromeToMobileReceiveBackend {
+ public:
+  enum BackendOperation{
+    kStartDevice,
+    kStopDevice,
+    kFetchJobs,
+    kCancelAllPendingOperations,
+  };
+
+  TestChromeToMobileReceiveBackend(
+      ChromeToMobileReceiveFrontend* frontend,
+      net::URLRequestContextGetter* request_context_getter);
+
+  // |ChromeToMobileBackendHost|
+  virtual void StartDevice(
+      const std::string& printer_id,
+      const std::map<std::string, std::string>& printer_tags) OVERRIDE;
+  virtual void StopDevice(const std::string& printer_id)
+                          OVERRIDE;
+  virtual void FetchJobs(const std::string& printer_id)
+                         OVERRIDE;
+  virtual void CancelAllPendingOperations() OVERRIDE;
+  virtual void ShutDown() OVERRIDE;
+  virtual void Start() OVERRIDE;
+  virtual bool IsRunning() const OVERRIDE;
+
+  // Methods to simulate backend behavior.
+  void StartDeviceComplete(bool success, std::string printer_id);
+  void StopDeviceComplete(bool success);
+  void CancelAllPendingOperationsComplete();
+  void OnCloudPrintAuthError();
+  void OnOAuthAccessFetchError();
+
+  // Mehtods to access backend status.
+  std::vector<std::pair<BackendOperation, bool> > GetPendingOperations() const;
+
+ protected:
+  virtual ~TestChromeToMobileReceiveBackend();
+
+ private:
+  friend class base::RefCountedThreadSafe<ChromeToMobileReceiveBackend>;
+
+  void SubmitOperation(BackendOperation operation);
+  std::vector<std::pair<BackendOperation, bool> >::iterator FindOperation(
+        BackendOperation op, bool is_completed);
+  void CompleteOperation(BackendOperation operation);
+
+  ChromeToMobileReceiveFrontend* frontend_;
+  // Map from an operatoin to a boolean indicating if it is completed or not.
+  std::vector<std::pair<BackendOperation, bool> > submitted_operations_;
+  bool is_thread_running_;
+};
+
+TestChromeToMobileReceiveBackend::TestChromeToMobileReceiveBackend(
+    ChromeToMobileReceiveFrontend* frontend,
+    net::URLRequestContextGetter* request_context_getter)
+    : ChromeToMobileReceiveBackend(NULL,
+                                   GURL("http://www.google.com/cloudprint"),
+                                   request_context_getter,
+                                   NULL),
+      frontend_(frontend),
+      is_thread_running_(true) {
+}
+
+TestChromeToMobileReceiveBackend::~TestChromeToMobileReceiveBackend() {
+}
+
+void TestChromeToMobileReceiveBackend::ShutDown() {
+  is_thread_running_ = false;
+  submitted_operations_.clear();
+}
+
+void TestChromeToMobileReceiveBackend::Start() {
+  is_thread_running_ = true;
+}
+
+bool TestChromeToMobileReceiveBackend::IsRunning() const {
+  return is_thread_running_;
+}
+
+void TestChromeToMobileReceiveBackend::StartDevice(
+    const std::string& printer_id,
+    const std::map<std::string, std::string>& printer_tags) {
+  SubmitOperation(kStartDevice);
+}
+
+void TestChromeToMobileReceiveBackend::StopDevice(
+    const std::string& printer_id) {
+  SubmitOperation(kStopDevice);
+}
+
+void TestChromeToMobileReceiveBackend::FetchJobs(
+    const std::string& printer_id) {
+  SubmitOperation(kFetchJobs);
+}
+
+void TestChromeToMobileReceiveBackend::CancelAllPendingOperations() {
+  SubmitOperation(kCancelAllPendingOperations);
+}
+
+void TestChromeToMobileReceiveBackend::StartDeviceComplete(
+    bool success, std::string printer_id) {
+  CompleteOperation(kStartDevice);
+  frontend_->OnStartDeviceComplete(success, printer_id);
+}
+
+void TestChromeToMobileReceiveBackend::StopDeviceComplete(bool success) {
+  CompleteOperation(kStopDevice);
+  submitted_operations_.clear();
+  frontend_->OnStopDeviceComplete(success);
+}
+
+void TestChromeToMobileReceiveBackend::CancelAllPendingOperationsComplete() {
+  submitted_operations_.clear();
+  frontend_->OnCancelAllPendingOperationsComplete();
+}
+
+void TestChromeToMobileReceiveBackend::OnCloudPrintAuthError() {
+  frontend_->OnCloudPrintAuthError();
+}
+
+void TestChromeToMobileReceiveBackend::OnOAuthAccessFetchError() {
+  frontend_->OnOAuth2AccessTokenFetchError();
+}
+
+std::vector<std::pair<
+    TestChromeToMobileReceiveBackend::BackendOperation, bool> >
+    TestChromeToMobileReceiveBackend::GetPendingOperations() const {
+  std::vector<std::pair<BackendOperation, bool> > results;
+  std::vector<std::pair<BackendOperation, bool> >::const_iterator iter =
+      submitted_operations_.begin();
+  for (; iter != submitted_operations_.end(); ++iter) {
+    if (!iter->second)
+      results.push_back(*iter);
+  }
+  return results;
+}
+
+void TestChromeToMobileReceiveBackend::SubmitOperation(
+    BackendOperation operation) {
+  submitted_operations_.push_back(std::make_pair(operation, false));
+}
+
+std::vector<std::pair<
+    TestChromeToMobileReceiveBackend::BackendOperation, bool> >::iterator
+        TestChromeToMobileReceiveBackend::FindOperation(
+            BackendOperation operation, bool is_completed) {
+  std::vector<std::pair<BackendOperation, bool> >::iterator iter =
+      submitted_operations_.begin();
+  for (; iter != submitted_operations_.end(); ++iter) {
+    if (iter->first == operation && iter->second == is_completed)
+      return iter;
+  }
+  return iter;
+}
+
+void TestChromeToMobileReceiveBackend::CompleteOperation(BackendOperation op) {
+  std::vector<std::pair<BackendOperation, bool> >::iterator iter =
+      FindOperation(op, false);
+  DCHECK(iter != submitted_operations_.end());
+  iter->second = true;
+}
+
+class MockDeviceInfoFetcher : public ChromeToMobileReceivingDeviceInfoHandler {
+ public:
+  explicit MockDeviceInfoFetcher(ChromeToMobileReceiveService* service);
+  virtual ~MockDeviceInfoFetcher();
+
+  // |ChromeToMobileReceivingDeviceInfoHandler|
+  virtual bool IsSupported() const OVERRIDE;
+  virtual void Start() OVERRIDE;
+  virtual bool HasRequiredInformation(
+    std::map<std::string, std::string> printer_tags) const OVERRIDE;
+
+  bool HasReceivedRequest() const;
+  void EnableDeviceForChromeToMobileReceiving(bool enabled);
+  void CompleteFetchingDeviceInformation(bool success);
+
+ private:
+  ChromeToMobileReceiveService* service_;
+  bool has_received_requested_;
+  bool enabled_;
+};
+
+MockDeviceInfoFetcher::MockDeviceInfoFetcher(
+    ChromeToMobileReceiveService* service)
+    : service_(service),
+      has_received_requested_(false),
+      enabled_(false) {
+};
+
+MockDeviceInfoFetcher::~MockDeviceInfoFetcher() {
+};
+
+bool MockDeviceInfoFetcher::IsSupported() const {
+  return enabled_;
+}
+
+void MockDeviceInfoFetcher::Start() {
+  has_received_requested_ = true;
+}
+
+bool MockDeviceInfoFetcher::HasRequiredInformation(
+    std::map<std::string, std::string> printer_tags) const {
+  return !printer_tags.empty();
+}
+
+bool MockDeviceInfoFetcher::HasReceivedRequest() const {
+  return has_received_requested_;
+}
+
+void MockDeviceInfoFetcher::EnableDeviceForChromeToMobileReceiving(
+    bool enable) {
+  enabled_ = enable;
+}
+
+void MockDeviceInfoFetcher::CompleteFetchingDeviceInformation(
+    bool success) {
+  DCHECK(HasReceivedRequest() || enabled_);
+  has_received_requested_ = false;
+  if (success) {
+    std::map<std::string, std::string> printer_tags;
+    printer_tags["package"] = std::string("test");
+    service_->SetDeviceTags(printer_tags);
+    return;
+  }
+
+  service_->OnFailToFetchDeviceInfo();
+}
+
+}  // namespace
+
+// Class that tests |ChromeToMobileReceiveService|.
+class ChromeToMobileReceiveServiceTest : public PlatformTest {
+ public:
+  ChromeToMobileReceiveServiceTest();
+  virtual ~ChromeToMobileReceiveServiceTest();
+  virtual void SetUp() OVERRIDE;
+
+  static ProfileKeyedService* CreateTokenService(Profile* profile);
+
+  // Methods that simulate user actions.
+  void SetCredentials();
+  void SetAuthToken(std::string service, std::string token, bool success);
+  void SetRelevantAuthToken(std::string token, bool success);
+  void SignOut();
+
+  MessageLoop ui_loop_;
+  scoped_ptr<content::TestBrowserThread> ui_thread_;
+  scoped_ptr<TestingProfile> profile_;
+  scoped_ptr<ChromeToMobileReceiveService> service_;
+  scoped_refptr<TestChromeToMobileReceiveBackend> backend_;
+  MockDeviceInfoFetcher* device_info_handler_;
+  scoped_ptr<FakeSigninManager> signin_;
+};
+
+ChromeToMobileReceiveServiceTest::ChromeToMobileReceiveServiceTest()
+  : profile_(new TestingProfile()) {
+}
+
+ChromeToMobileReceiveServiceTest::~ChromeToMobileReceiveServiceTest() {
+}
+
+// static
+ProfileKeyedService* ChromeToMobileReceiveServiceTest::CreateTokenService(
+    Profile* profile) {
+  TokenService* token_service = new TokenService();
+  token_service->Initialize("chrome-to-mobile-receive", profile);
+  return token_service;
+}
+
+void ChromeToMobileReceiveServiceTest::SetUp() {
+  PlatformTest::SetUp();
+  ui_thread_.reset(new content::TestBrowserThread(content::BrowserThread::UI,
+                                                  &ui_loop_));
+  TokenServiceFactory::GetInstance()->SetTestingFactory(profile_.get(),
+                                                        &CreateTokenService);
+
+  service_.reset(new ChromeToMobileReceiveService(profile_.get()));
+
+  backend_ = new TestChromeToMobileReceiveBackend(
+      service_.get(),
+      profile_->GetRequestContext());
+  service_->backend_ = backend_;
+
+  device_info_handler_ = new MockDeviceInfoFetcher(service_.get());
+  service_->device_info_handler_.reset(device_info_handler_);
+
+  signin_.reset(new FakeSigninManager(profile_.get()));
+
+  profile_->GetPrefs()->SetBoolean(
+      prefs::kChromeToMobileReceiveEnabled, true);
+}
+
+void ChromeToMobileReceiveServiceTest::SetCredentials() {
+  GaiaAuthConsumer::ClientLoginResult result("test sid",
+                                             "test lsid",
+                                             "test token",
+                                             "test data");
+  content::NotificationService::current()->Notify(
+      chrome::NOTIFICATION_GOOGLE_SIGNIN_SUCCESSFUL,
+      content::Source<Profile>(profile_.get()),
+      content::Details<const GoogleServiceSigninSuccessDetails>(NULL));
+  TokenServiceFactory::GetForProfile(profile_.get())->
+      UpdateCredentials(result);
+}
+
+void ChromeToMobileReceiveServiceTest::SetAuthToken(
+    std::string service, std::string token, bool success) {
+  if (success) {
+    TokenServiceFactory::GetForProfile(profile_.get())->
+        IssueAuthTokenForTest(service, token);
+  } else {
+    GoogleServiceAuthError error(GoogleServiceAuthError::SERVICE_UNAVAILABLE);
+    TokenServiceFactory::GetForProfile(profile_.get())->
+        OnIssueAuthTokenFailure(service, error);
+  }
+}
+
+void ChromeToMobileReceiveServiceTest::SetRelevantAuthToken(
+    std::string token, bool success) {
+  SetAuthToken(GaiaConstants::kGaiaOAuth2LoginRefreshToken, token, success);
+}
+
+void ChromeToMobileReceiveServiceTest::SignOut() {
+  TokenService* token_service = TokenServiceFactory::GetForProfile(
+      profile_.get());
+  token_service->ResetCredentialsInMemory();
+  token_service->EraseTokensFromDB();
+  signin_->SignOut();
+}
+
+TEST_F(ChromeToMobileReceiveServiceTest, Init) {
+  // When the application starts, the user has not signed in and the
+  // chrome-to-mobile option in preference defaults to be on.
+  EXPECT_FALSE(service_->IsAuthenticationReady());
+  EXPECT_TRUE(service_->IsTurnedOnInPreference());
+  EXPECT_FALSE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kNoFailure,
+            service_->GetFailureType());
+  EXPECT_FALSE(device_info_handler_->HasReceivedRequest());
+}
+
+TEST_F(ChromeToMobileReceiveServiceTest, SignInWithCredentialsOnly) {
+  // Only credential is availble; oauth token is still missing.
+  SetCredentials();
+
+  EXPECT_FALSE(service_->IsAuthenticationReady());
+  EXPECT_TRUE(service_->IsTurnedOnInPreference());
+  EXPECT_FALSE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kNoFailure,
+            service_->GetFailureType());
+  EXPECT_FALSE(device_info_handler_->HasReceivedRequest());
+}
+
+TEST_F(ChromeToMobileReceiveServiceTest,
+       SignInWithCredentailsAndNonRelevantAuthToken) {
+  SetCredentials();
+  SetAuthToken(GaiaConstants::kSyncService, "test sync token", true);
+
+  EXPECT_FALSE(service_->IsAuthenticationReady());
+  EXPECT_TRUE(service_->IsTurnedOnInPreference());
+  EXPECT_FALSE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kNoFailure,
+            service_->GetFailureType());
+  EXPECT_FALSE(device_info_handler_->HasReceivedRequest());
+}
+
+TEST_F(ChromeToMobileReceiveServiceTest,
+       SignInWithAuthTokenFailure) {
+  SetRelevantAuthToken("test token", false);
+
+  EXPECT_FALSE(service_->IsAuthenticationReady());
+  EXPECT_TRUE(service_->IsTurnedOnInPreference());
+  EXPECT_FALSE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kNoFailure,
+            service_->GetFailureType());
+  EXPECT_FALSE(device_info_handler_->HasReceivedRequest());
+}
+
+TEST_F(ChromeToMobileReceiveServiceTest,
+       SignInDeviceNotSupported) {
+  SetRelevantAuthToken("test token", true);
+  device_info_handler_->EnableDeviceForChromeToMobileReceiving(false);
+
+  EXPECT_TRUE(service_->IsAuthenticationReady());
+  EXPECT_TRUE(service_->IsTurnedOnInPreference());
+  EXPECT_FALSE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kNoFailure,
+            service_->GetFailureType());
+  EXPECT_TRUE(device_info_handler_->HasReceivedRequest());
+}
+
+TEST_F(ChromeToMobileReceiveServiceTest,
+       SignInDeviceDisabledAndThenEnabled) {
+  SetRelevantAuthToken("test token", true);
+  device_info_handler_->EnableDeviceForChromeToMobileReceiving(false);
+  device_info_handler_->EnableDeviceForChromeToMobileReceiving(true);
+  EXPECT_TRUE(service_->IsAuthenticationReady());
+  EXPECT_TRUE(service_->IsTurnedOnInPreference());
+  EXPECT_TRUE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kNoFailure,
+            service_->GetFailureType());
+  EXPECT_TRUE(device_info_handler_->HasReceivedRequest());
+}
+
+TEST_F(ChromeToMobileReceiveServiceTest,
+       SignInDeviceEnabledDeviceInfoFetchSucceed) {
+  SetRelevantAuthToken("test token", true);
+  device_info_handler_->EnableDeviceForChromeToMobileReceiving(true);
+  EXPECT_TRUE(service_->IsAuthenticationReady());
+  EXPECT_TRUE(service_->IsTurnedOnInPreference());
+  EXPECT_TRUE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kNoFailure,
+            service_->GetFailureType());
+  EXPECT_TRUE(device_info_handler_->HasReceivedRequest());
+
+  device_info_handler_->CompleteFetchingDeviceInformation(true);
+  EXPECT_TRUE(service_->IsAuthenticationReady());
+  EXPECT_TRUE(service_->IsTurnedOnInPreference());
+  EXPECT_TRUE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kNoFailure,
+            service_->GetFailureType());
+  EXPECT_EQ(1U, backend_->GetPendingOperations().size())
+      << "Service should start the device";
+}
+
+TEST_F(ChromeToMobileReceiveServiceTest,
+       SignInDeviceEnabledDeviceInfoFetchFail) {
+  SetRelevantAuthToken("test token", true);
+  device_info_handler_->EnableDeviceForChromeToMobileReceiving(true);
+  device_info_handler_->CompleteFetchingDeviceInformation(false);
+
+  EXPECT_TRUE(service_->IsAuthenticationReady());
+  EXPECT_FALSE(service_->IsTurnedOnInPreference());
+  EXPECT_TRUE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kDeviceInfoFetchFailure,
+            service_->GetFailureType());
+  EXPECT_EQ(0U, backend_->GetPendingOperations().size());
+}
+
+TEST_F(ChromeToMobileReceiveServiceTest,
+       SignInDeviceEnabledDeviceInfoFetchFailTurnOnAgain) {
+  SetRelevantAuthToken("test token", true);
+  device_info_handler_->EnableDeviceForChromeToMobileReceiving(true);
+  device_info_handler_->CompleteFetchingDeviceInformation(false);
+
+  EXPECT_TRUE(service_->IsAuthenticationReady());
+  EXPECT_FALSE(service_->IsTurnedOnInPreference());
+  EXPECT_TRUE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kDeviceInfoFetchFailure,
+            service_->GetFailureType());
+  EXPECT_EQ(0U, backend_->GetPendingOperations().size());
+
+  service_->TurnOnPreference(true);
+  // Device information should be requested again because there has no
+  // successful fetch.
+  device_info_handler_->CompleteFetchingDeviceInformation(true);
+  EXPECT_TRUE(service_->IsAuthenticationReady());
+  EXPECT_TRUE(service_->IsTurnedOnInPreference());
+  EXPECT_TRUE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kNoFailure,
+            service_->GetFailureType());
+  EXPECT_EQ(1U, backend_->GetPendingOperations().size());
+}
+
+TEST_F(ChromeToMobileReceiveServiceTest,
+       SignInGetDeviceInfoStartDeviceFail) {
+  SetRelevantAuthToken("test token", true);
+  device_info_handler_->EnableDeviceForChromeToMobileReceiving(true);
+  device_info_handler_->CompleteFetchingDeviceInformation(true);
+  backend_->StartDeviceComplete(false, std::string("printer id"));
+
+  EXPECT_TRUE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_FALSE(service_->IsTurnedOnInPreference());
+  EXPECT_EQ(ChromeToMobileReceiveService::kStartDeviceFailure,
+            service_->GetFailureType());
+  EXPECT_TRUE(service_->IsAuthenticationReady());
+  EXPECT_EQ(0U, backend_->GetPendingOperations().size());
+}
+
+TEST_F(ChromeToMobileReceiveServiceTest,
+       SignInGetDeviceInfoStartDeviceFailTurnOnAgain) {
+  SetRelevantAuthToken("test token", true);
+  device_info_handler_->EnableDeviceForChromeToMobileReceiving(true);
+  device_info_handler_->CompleteFetchingDeviceInformation(true);
+  backend_->StartDeviceComplete(false, std::string("printer id"));
+  service_->TurnOnPreference(true);
+
+  EXPECT_TRUE(service_->IsAuthenticationReady());
+  EXPECT_TRUE(service_->IsTurnedOnInPreference());
+  EXPECT_TRUE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kNoFailure,
+            service_->GetFailureType());
+  EXPECT_EQ(1U, backend_->GetPendingOperations().size());
+}
+
+TEST_F(ChromeToMobileReceiveServiceTest,
+       SignInGetDeviceInfoStartDeviceSucceed) {
+  SetRelevantAuthToken("test token", true);
+  device_info_handler_->EnableDeviceForChromeToMobileReceiving(true);
+  device_info_handler_->CompleteFetchingDeviceInformation(true);
+  backend_->StartDeviceComplete(true, std::string("printer id"));
+
+  EXPECT_TRUE(service_->IsAuthenticationReady());
+  EXPECT_TRUE(service_->IsTurnedOnInPreference());
+  EXPECT_TRUE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kNoFailure,
+            service_->GetFailureType());
+  EXPECT_EQ(1U, backend_->GetPendingOperations().size());
+  EXPECT_EQ(TestChromeToMobileReceiveBackend::kFetchJobs,
+            backend_->GetPendingOperations().at(0).first);
+}
+
+TEST_F(ChromeToMobileReceiveServiceTest,
+       SignInGetDeviceInfoStartDeviceCloudPrintAuthFailure) {
+  SetRelevantAuthToken("test token", true);
+  device_info_handler_->EnableDeviceForChromeToMobileReceiving(true);
+  device_info_handler_->CompleteFetchingDeviceInformation(true);
+  backend_->OnCloudPrintAuthError();
+  backend_->StartDeviceComplete(false, std::string("printer id"));
+
+  EXPECT_TRUE(service_->IsAuthenticationReady());
+  EXPECT_FALSE(service_->IsTurnedOnInPreference());
+  EXPECT_TRUE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kClouPrintAuthError,
+            service_->GetFailureType());
+  EXPECT_EQ(1U, backend_->GetPendingOperations().size());
+
+  backend_->CancelAllPendingOperationsComplete();
+  EXPECT_TRUE(service_->IsAuthenticationReady());
+  EXPECT_FALSE(service_->IsTurnedOnInPreference());
+  EXPECT_TRUE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kClouPrintAuthError,
+            service_->GetFailureType());
+  EXPECT_EQ(0U, backend_->GetPendingOperations().size());
+}
+
+TEST_F(ChromeToMobileReceiveServiceTest,
+       SignInGetDeviceInfoStartDeviceOAuth2AccessTokenFetchFail) {
+  SetRelevantAuthToken("test token", true);
+  device_info_handler_->EnableDeviceForChromeToMobileReceiving(true);
+  device_info_handler_->CompleteFetchingDeviceInformation(true);
+  backend_->OnOAuthAccessFetchError();
+  backend_->StartDeviceComplete(false, std::string("printer id"));
+
+  EXPECT_TRUE(service_->IsAuthenticationReady());
+  EXPECT_FALSE(service_->IsTurnedOnInPreference());
+  EXPECT_TRUE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kOAuthTokenFetchFailure,
+            service_->GetFailureType());
+  EXPECT_EQ(1U, backend_->GetPendingOperations().size());
+
+  backend_->CancelAllPendingOperationsComplete();
+  EXPECT_TRUE(service_->IsAuthenticationReady());
+  EXPECT_FALSE(service_->IsTurnedOnInPreference());
+  EXPECT_TRUE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kOAuthTokenFetchFailure,
+            service_->GetFailureType());
+  EXPECT_EQ(0U, backend_->GetPendingOperations().size());
+}
+
+TEST_F(ChromeToMobileReceiveServiceTest,
+       SignInGetDeviceInfoStartDeviceAuthFailSignOut) {
+  SetRelevantAuthToken("test token", true);
+  device_info_handler_->EnableDeviceForChromeToMobileReceiving(true);
+  device_info_handler_->CompleteFetchingDeviceInformation(true);
+  backend_->OnOAuthAccessFetchError();
+  backend_->StartDeviceComplete(false, std::string("printer id"));
+  backend_->CancelAllPendingOperationsComplete();
+
+  SignOut();
+  EXPECT_FALSE(service_->IsAuthenticationReady());
+  EXPECT_FALSE(service_->IsTurnedOnInPreference());
+  EXPECT_FALSE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kNoFailure,
+            service_->GetFailureType());
+  EXPECT_FALSE(backend_->IsRunning());
+  EXPECT_EQ(0U, backend_->GetPendingOperations().size());
+}
+
+TEST_F(ChromeToMobileReceiveServiceTest,
+       SignInGetDeviceInfoStartDeviceAuthFailSignOutAndSignIn) {
+  SetRelevantAuthToken("test token", true);
+  device_info_handler_->EnableDeviceForChromeToMobileReceiving(true);
+  device_info_handler_->CompleteFetchingDeviceInformation(true);
+  backend_->OnOAuthAccessFetchError();
+  backend_->StartDeviceComplete(false, std::string("printer id"));
+  backend_->CancelAllPendingOperationsComplete();
+
+  SignOut();
+  SetRelevantAuthToken("test token", true);
+
+  EXPECT_TRUE(service_->IsAuthenticationReady());
+  EXPECT_TRUE(service_->IsTurnedOnInPreference());
+  EXPECT_TRUE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kNoFailure,
+            service_->GetFailureType());
+  EXPECT_EQ(1U, backend_->GetPendingOperations().size());
+}
+
+TEST_F(ChromeToMobileReceiveServiceTest,
+       SignInGetDeviceInfoStartDeviceTurnOffBeforeStartCompletes) {
+  SetRelevantAuthToken("test token", true);
+  device_info_handler_->EnableDeviceForChromeToMobileReceiving(true);
+  device_info_handler_->CompleteFetchingDeviceInformation(true);
+  service_->TurnOnPreference(false);
+
+  EXPECT_TRUE(service_->IsAuthenticationReady());
+  EXPECT_FALSE(service_->IsTurnedOnInPreference());
+  EXPECT_TRUE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kNoFailure,
+            service_->GetFailureType());
+  EXPECT_EQ(2U, backend_->GetPendingOperations().size());
+
+  backend_->StopDeviceComplete(true);
+
+  EXPECT_TRUE(service_->IsAuthenticationReady());
+  EXPECT_FALSE(service_->IsTurnedOnInPreference());
+  EXPECT_TRUE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kNoFailure,
+            service_->GetFailureType());
+  EXPECT_EQ(0U, backend_->GetPendingOperations().size());
+}
+
+TEST_F(ChromeToMobileReceiveServiceTest,
+       SignInGetDeviceInfoStartDeviceTurnOffAfterStartCompletes) {
+  SetRelevantAuthToken("test token", true);
+  device_info_handler_->EnableDeviceForChromeToMobileReceiving(true);
+  device_info_handler_->CompleteFetchingDeviceInformation(true);
+  backend_->StartDeviceComplete(true, std::string("printer id"));
+  service_->TurnOnPreference(false);
+
+  EXPECT_TRUE(service_->IsAuthenticationReady());
+  EXPECT_FALSE(service_->IsTurnedOnInPreference());
+  EXPECT_TRUE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kNoFailure,
+            service_->GetFailureType());
+  EXPECT_EQ(2U, backend_->GetPendingOperations().size());
+
+  backend_->StopDeviceComplete(true);
+
+  EXPECT_TRUE(service_->IsAuthenticationReady());
+  EXPECT_FALSE(service_->IsTurnedOnInPreference());
+  EXPECT_TRUE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kNoFailure,
+            service_->GetFailureType());
+  EXPECT_EQ(0U, backend_->GetPendingOperations().size());
+}
+
+TEST_F(ChromeToMobileReceiveServiceTest,
+       StartWithAuthErrorSignOutAndSignIn) {
+  SetRelevantAuthToken("test token", true);
+  device_info_handler_->EnableDeviceForChromeToMobileReceiving(true);
+  device_info_handler_->CompleteFetchingDeviceInformation(true);
+  backend_->OnOAuthAccessFetchError();
+  backend_->StartDeviceComplete(false, std::string(""));
+  backend_->CancelAllPendingOperationsComplete();
+
+  EXPECT_TRUE(service_->IsAuthenticationReady());
+  EXPECT_FALSE(service_->IsTurnedOnInPreference());
+  EXPECT_TRUE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kOAuthTokenFetchFailure,
+            service_->GetFailureType());
+  EXPECT_EQ(0U, backend_->GetPendingOperations().size());
+
+  SignOut();
+  SetRelevantAuthToken("test token", true);
+
+  EXPECT_TRUE(service_->IsAuthenticationReady());
+  EXPECT_TRUE(service_->IsTurnedOnInPreference());
+  EXPECT_TRUE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kNoFailure,
+            service_->GetFailureType());
+  EXPECT_EQ(1U, backend_->GetPendingOperations().size());
+}
+
+TEST_F(ChromeToMobileReceiveServiceTest,
+       StartFetchBeforeStartFailure) {
+  SetRelevantAuthToken("test token", true);
+  device_info_handler_->EnableDeviceForChromeToMobileReceiving(true);
+  device_info_handler_->CompleteFetchingDeviceInformation(true);
+  service_->FetchPendingJobs();
+
+  EXPECT_TRUE(service_->IsAuthenticationReady());
+  EXPECT_TRUE(service_->IsTurnedOnInPreference());
+  EXPECT_TRUE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kNoFailure,
+            service_->GetFailureType());
+  EXPECT_EQ(1U, backend_->GetPendingOperations().size());
+
+  backend_->StartDeviceComplete(false, std::string(""));
+
+  EXPECT_TRUE(service_->IsAuthenticationReady());
+  EXPECT_FALSE(service_->IsTurnedOnInPreference());
+  EXPECT_TRUE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kStartDeviceFailure,
+            service_->GetFailureType());
+  EXPECT_EQ(0U, backend_->GetPendingOperations().size());
+}
+
+TEST_F(ChromeToMobileReceiveServiceTest,
+       StartAndFetchBeforeStartAuthFailure) {
+  SetRelevantAuthToken("test token", true);
+  device_info_handler_->EnableDeviceForChromeToMobileReceiving(true);
+  device_info_handler_->CompleteFetchingDeviceInformation(true);
+  service_->FetchPendingJobs();
+  backend_->StartDeviceComplete(false, std::string(""));
+  backend_->OnOAuthAccessFetchError();
+
+  EXPECT_TRUE(service_->IsAuthenticationReady());
+  EXPECT_FALSE(service_->IsTurnedOnInPreference());
+  EXPECT_TRUE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kStartDeviceFailure,
+            service_->GetFailureType());
+  EXPECT_EQ(0U, backend_->GetPendingOperations().size());
+}
+
+TEST_F(ChromeToMobileReceiveServiceTest,
+       RestartWhileTurningOff) {
+  SetRelevantAuthToken("test token", true);
+  device_info_handler_->EnableDeviceForChromeToMobileReceiving(true);
+  device_info_handler_->CompleteFetchingDeviceInformation(true);
+  backend_->StartDeviceComplete(true, std::string("printer"));
+  EXPECT_EQ(1U, backend_->GetPendingOperations().size());
+
+  service_->TurnOnPreference(false);
+  service_->TurnOnPreference(true);
+
+  EXPECT_EQ(2U, backend_->GetPendingOperations().size());
+
+  backend_->StopDeviceComplete(true);
+
+  EXPECT_EQ(1U, backend_->GetPendingOperations().size());
+  backend_->StartDeviceComplete(true, std::string("printer id"));
+
+  EXPECT_TRUE(service_->IsAuthenticationReady());
+  EXPECT_TRUE(service_->IsTurnedOnInPreference());
+  EXPECT_TRUE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kNoFailure,
+            service_->GetFailureType());
+  EXPECT_EQ(1U, backend_->GetPendingOperations().size());
+  EXPECT_EQ(TestChromeToMobileReceiveBackend::kFetchJobs,
+            backend_->GetPendingOperations().at(0).first);
+}
+
+TEST_F(ChromeToMobileReceiveServiceTest,
+       SignOutBeforeStartComplete) {
+  SetRelevantAuthToken("test token", true);
+  device_info_handler_->EnableDeviceForChromeToMobileReceiving(true);
+  device_info_handler_->CompleteFetchingDeviceInformation(true);
+  EXPECT_EQ(1U, backend_->GetPendingOperations().size());
+
+  SignOut();
+  EXPECT_EQ(2U, backend_->GetPendingOperations().size());
+
+  backend_->StopDeviceComplete(true);
+
+  EXPECT_FALSE(service_->IsAuthenticationReady());
+  EXPECT_TRUE(service_->IsTurnedOnInPreference());
+  EXPECT_EQ(ChromeToMobileReceiveService::kNoFailure,
+            service_->GetFailureType());
+  EXPECT_FALSE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(0U, backend_->GetPendingOperations().size());
+}
+
+TEST_F(ChromeToMobileReceiveServiceTest,
+       SignOutAfterStartComplete) {
+  SetRelevantAuthToken("test token", true);
+  device_info_handler_->EnableDeviceForChromeToMobileReceiving(true);
+  device_info_handler_->CompleteFetchingDeviceInformation(true);
+  backend_->StartDeviceComplete(true, std::string("printer"));
+  EXPECT_EQ(1U, backend_->GetPendingOperations().size());
+
+  SignOut();
+
+  EXPECT_EQ(2U, backend_->GetPendingOperations().size());
+  EXPECT_FALSE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_TRUE(service_->IsTurnedOnInPreference());
+  EXPECT_EQ(ChromeToMobileReceiveService::kNoFailure,
+            service_->GetFailureType());
+  EXPECT_FALSE(service_->IsAuthenticationReady());
+
+  backend_->StopDeviceComplete(true);
+
+  EXPECT_EQ(0U, backend_->GetPendingOperations().size());
+  EXPECT_FALSE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_TRUE(service_->IsTurnedOnInPreference());
+  EXPECT_EQ(ChromeToMobileReceiveService::kNoFailure,
+            service_->GetFailureType());
+  EXPECT_FALSE(service_->IsAuthenticationReady());
+}
+
+TEST_F(ChromeToMobileReceiveServiceTest,
+       SignOutWhileTurningOff) {
+  SetRelevantAuthToken("test token", true);
+  device_info_handler_->EnableDeviceForChromeToMobileReceiving(true);
+  device_info_handler_->CompleteFetchingDeviceInformation(true);
+  backend_->StartDeviceComplete(true, std::string("printer"));
+
+  service_->TurnOnPreference(false);
+  SignOut();
+
+  backend_->CancelAllPendingOperationsComplete();
+
+  EXPECT_EQ(0U, backend_->GetPendingOperations().size());
+  EXPECT_FALSE(service_->IsAuthenticationReady());
+  EXPECT_FALSE(service_->IsTurnedOnInPreference());
+  EXPECT_FALSE(service_->CanGetStartedIfTurnedOn());
+  EXPECT_EQ(ChromeToMobileReceiveService::kNoFailure,
+            service_->GetFailureType());
+}