Support chrome_to_mobile job receiving

chrome/browser/chrome_to_mobile/receive/chrome_to_mobile_receive_backend.cc

+// 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 "chrome/browser/chrome_to_mobile/receive/chrome_to_mobile_receive_backend.h"
+
+#include "base/bind.h"
+#include "base/message_loop.h"
+#include "chrome/browser/chrome_to_mobile/receive/chrome_to_mobile_receive_job_observer.h"
+#include "chrome/browser/signin/oauth2_token_service.h"
+#include "chrome/browser/chrome_to_mobile/receive/chrome_to_mobile_receive_util.h"
+#include "chrome/common/cloud_print/cloud_print_helpers.h"
+#include "content/public/browser/browser_thread.h"
+
+namespace chrome_to_mobile_receive {
+ChromeToMobileReceiveBackend::ChromeToMobileReceiveBackend(
+    ChromeToMobileReceiveFrontend* frontend,
+    const GURL& cloud_print_server_url,
+    net::URLRequestContextGetter* request_context_getter,
+    OAuth2TokenService* oauth2_token_service)
+    : frontend_(frontend),
+      frontend_loop_(MessageLoop::current()),
+      chrome_to_mobile_thread_("Chrome_ChromeToMobileThread"),
+      cloud_print_server_url_(cloud_print_server_url),
+      request_context_getter_(request_context_getter),
+      oauth2_token_service_(oauth2_token_service) {
+  chrome_to_mobile_thread_.Start();
+}
+
+ChromeToMobileReceiveBackend::~ChromeToMobileReceiveBackend() {
+}
+
+void ChromeToMobileReceiveBackend::Start() {
+  chrome_to_mobile_thread_.Start();
+}
+
+bool ChromeToMobileReceiveBackend::IsRunning() const {
+  return chrome_to_mobile_thread_.IsRunning();
+}
+
+void ChromeToMobileReceiveBackend::ShutDown() {
+  DCHECK(MessageLoop::current() == frontend_loop_);
+
+  stop_device_request_.reset();
+  PostToChromeToMobileThread(base::Bind(
+      &ChromeToMobileReceiveBackend::CancelAllPendingRequestsOnBackendThreads,
+      this));
+  content::BrowserThread::PostBlockingPoolTask(FROM_HERE,
+    base::Bind(&ChromeToMobileReceiveBackend::StopThread, this));
+}
+
+void ChromeToMobileReceiveBackend::StopThread() {
+  chrome_to_mobile_thread_.Stop();
+}
+
+void ChromeToMobileReceiveBackend::CancelAllPendingRequestsOnBackendThreads() {
+  DCHECK(MessageLoop::current() == chrome_to_mobile_thread_.message_loop());
+  device_manager_.reset();
+  snapshots_fetcher_.reset();
+  print_jobs_fetcher_.reset();
+}
+
+void ChromeToMobileReceiveBackend::CancelAllPendingOperations() {
+  DCHECK(MessageLoop::current() == frontend_loop_);
+  stop_device_request_.reset();
+  PostToChromeToMobileThread(base::Bind(
+      &ChromeToMobileReceiveBackend::DoCancelAllPendingOperations, this));
+}
+
+void ChromeToMobileReceiveBackend::DoCancelAllPendingOperations() {
+  DCHECK(MessageLoop::current() == chrome_to_mobile_thread_.message_loop());
+  CancelAllPendingRequestsOnBackendThreads();
+  PostToFrontendThread(base::Bind(
+      &ChromeToMobileReceiveFrontend::OnCancelAllPendingOperationsComplete,
+      base::Unretained(frontend_)));
+}
+
+void ChromeToMobileReceiveBackend::StartDevice(
+    const std::string& printer_id,
+    const std::map<std::string, std::string>& printer_tags) {
+  DCHECK(MessageLoop::current() == frontend_loop_);
+  PostToChromeToMobileThread(base::Bind(
+      &ChromeToMobileReceiveBackend::DoStartDevice, this,
+      printer_id, printer_tags));
+}
+
+void ChromeToMobileReceiveBackend::DoStartDevice(
+    const std::string printer_id,
+    const std::map<std::string, std::string> printer_tags) {
+  DCHECK(MessageLoop::current() == chrome_to_mobile_thread_.message_loop());
+
+  chrome_to_mobile::CloudPrintRequest::Settings request_settings(
+      kChromeToMobileClientParameter,
+      request_context_getter_,
+      oauth2_token_service_);
+  // Callback |OnStartDeviceComplete| will be called when this request
+  // completes.
+  device_manager_.reset(
+      ChromeToMobileReceiveDeviceManager::CreateAndStart(
+          cloud_print_server_url_,
+          printer_id,
+          printer_tags,
+          request_settings,
+          this));
+}
+
+void ChromeToMobileReceiveBackend::OnStartDeviceComplete(
+    ChromeToMobileReceiveDeviceManager* source) {
+  DCHECK(MessageLoop::current() == chrome_to_mobile_thread_.message_loop());
+  if (source->HasCloudPrintAuthError())
+    HandleCloudPrintAuthError();
+  if (source->HasOAuth2AccessTokenFailure())
+    HandleGetOAuth2AccessTokenFailure();
+
+  bool success = source->IsSuccess();
+  std::string printer_id = source->GetStartedPrinterId();
+  PostToFrontendThread(base::Bind(
+      &ChromeToMobileReceiveFrontend::OnStartDeviceComplete,
+      base::Unretained(frontend_), success, printer_id));
+  device_manager_.reset();
+}
+
+void ChromeToMobileReceiveBackend::StopDevice(
+    const std::string& printer_id) {
+  DCHECK(MessageLoop::current() == frontend_loop_);
+  PostToChromeToMobileThread(base::Bind(
+      &ChromeToMobileReceiveBackend::CancelAllPendingRequestsOnBackendThreads,
+      this));
+  chrome_to_mobile::CloudPrintRequest::Settings request_settings(
+      kChromeToMobileClientParameter,
+      request_context_getter_,
+      oauth2_token_service_);
+  // Callback |OnRequestComplete| will be called when this request completes.
+  stop_device_request_.reset(
+      chrome_to_mobile::CloudPrintRequest::CreateAndStartGetRequest(
+          cloud_print::GetUrlForPrinterDelete(cloud_print_server_url_,
+                                              printer_id,
+                                              "chrome_to_mobile_stopped"),
+      request_settings, this));
+}
+
+void ChromeToMobileReceiveBackend::OnRequestComplete(
+    chrome_to_mobile::CloudPrintRequest* source) {
+  DCHECK(MessageLoop::current() == frontend_loop_);
+  bool success;
+  source->GetResponseData(&success);
+  PostToFrontendThread(base::Bind(
+      &ChromeToMobileReceiveFrontend::OnStopDeviceComplete,
+      base::Unretained(frontend_), success));
+  stop_device_request_.reset();
+}
+
+void ChromeToMobileReceiveBackend::FetchJobs(
+    const std::string& printer_id) {
+  DCHECK(MessageLoop::current() == frontend_loop_);
+  PostToChromeToMobileThread(base::Bind(
+      &ChromeToMobileReceiveBackend::DoFetchJobs,
+      this, printer_id));
+}
+
+void ChromeToMobileReceiveBackend::DoFetchJobs(
+      std::string printer_id) {
+  DCHECK(MessageLoop::current() == chrome_to_mobile_thread_.message_loop());
+
+  chrome_to_mobile::CloudPrintRequest::Settings request_settings(
+      kChromeToMobileClientParameter,
+      request_context_getter_,
+      oauth2_token_service_);
+
+  if (!snapshots_fetcher_.get()) {
+    snapshots_fetcher_.reset(ChromeToMobileSnapshotsFetcher::Create(
+       cloud_print_server_url_, printer_id, request_settings, this));
+  }
+  if (!print_jobs_fetcher_.get()) {
+    print_jobs_fetcher_.reset(new ChromeToMobilePrintToPhoneJobsFetcher(
+        cloud_print_server_url_, printer_id, request_settings, this));
+  }
+  snapshots_fetcher_->Fetch();
+  print_jobs_fetcher_->Fetch();
+}
+
+void ChromeToMobileReceiveBackend::OnSnapshotsFetchComplete(
+    ChromeToMobileSnapshotsFetcher * source) {
+  DCHECK(MessageLoop::current() == chrome_to_mobile_thread_.message_loop());
+  if (source->HasCloudPrintAuthError())
+    HandleCloudPrintAuthError();
+  if (source->HasOAuth2AccessTokenFailure())
+    HandleGetOAuth2AccessTokenFailure();
+}
+
+void ChromeToMobileReceiveBackend::OnPrintJobsFetchComplete(
+    ChromeToMobilePrintToPhoneJobsFetcher* source) {
+  DCHECK(MessageLoop::current() == chrome_to_mobile_thread_.message_loop());
+  if (source->HasCloudPrintAuthError())
+    HandleCloudPrintAuthError();
+  if (source->HasOAuth2AccessTokenFailure())
+    HandleGetOAuth2AccessTokenFailure();
+}
+
+void ChromeToMobileReceiveBackend::OnSnapshotUrlFetched(
+    const std::string& snapshot_id,
+    const std::string& original_url,
+    const std::string& title,
+    const bool& is_offline_data_expected,
+    const std::string& create_time) {
+  DCHECK(MessageLoop::current() == chrome_to_mobile_thread_.message_loop());
+  PostToFrontendThread(base::Bind(
+      &ChromeToMobileReceiveBackend::DoOnSnapshotUrlFetched, this,
+      snapshot_id, original_url, title, is_offline_data_expected, create_time));
+}
+
+void ChromeToMobileReceiveBackend::DoOnSnapshotUrlFetched(
+    const std::string& snapshot_id,
+    const std::string& original_url,
+    const std::string& title,
+    const bool& is_offline_data_expected,
+    const std::string& create_time) {
+  DCHECK(MessageLoop::current() == frontend_loop_);
+  FOR_EACH_OBSERVER(
+      ChromeToMobileReceiveJobObserver, *frontend_->GetJobObservers(),
+      OnSnapshotUrlFetched(snapshot_id, original_url, title,
+          is_offline_data_expected, create_time));
+}
+
+void ChromeToMobileReceiveBackend::OnSnapshotDataDownloadComplete(
+    const std::string& snapshot_id,
+    const bool& success,
+    const std::string& data_mime_type,
+    const std::string& data) {
+  DCHECK(MessageLoop::current() == chrome_to_mobile_thread_.message_loop());
+  PostToFrontendThread(base::Bind(
+      &ChromeToMobileReceiveBackend::DoOnSnapshotDataDownloadComplete, this,
+      snapshot_id, success, data_mime_type, data));
+}
+
+void ChromeToMobileReceiveBackend::DoOnSnapshotDataDownloadComplete(
+    const std::string& snapshot_id,
+    const bool& success,
+    const std::string& data_mime_type,
+    const std::string& data) {
+  DCHECK(MessageLoop::current() == frontend_loop_);
+  FOR_EACH_OBSERVER(
+      ChromeToMobileReceiveJobObserver, *frontend_->GetJobObservers(),
+      OnSnapshotDataDownloadComplete(
+          snapshot_id, success, data_mime_type, data));
+}
+
+void ChromeToMobileReceiveBackend::OnPrintToPhoneJobDownloadStart(
+    const std::string& job_id,
+    const std::string& title) {
+  DCHECK(MessageLoop::current() == chrome_to_mobile_thread_.message_loop());
+  PostToFrontendThread(base::Bind(
+      &ChromeToMobileReceiveBackend::DoOnPrintToPhoneJobDownloadStart, this,
+      job_id, title));
+}
+
+void ChromeToMobileReceiveBackend::DoOnPrintToPhoneJobDownloadStart(
+    const std::string& job_id,
+    const std::string& title) {
+  DCHECK(MessageLoop::current() == frontend_loop_);
+  FOR_EACH_OBSERVER(
+      ChromeToMobileReceiveJobObserver, *frontend_->GetJobObservers(),
+      OnPrintToPhoneJobDownloadStart(job_id, title));
+}
+
+void ChromeToMobileReceiveBackend::OnPrintToPhoneJobDownloadComplete(
+      const std::string& job_id,
+      const bool& success,
+      const std::string& data_mime_type,
+      const std::string& data) {
+  DCHECK(MessageLoop::current() == chrome_to_mobile_thread_.message_loop());
+  PostToFrontendThread(base::Bind(
+      &ChromeToMobileReceiveBackend::DoOnPrintToPhoneJobDownloadComplete, this,
+      job_id, success, data_mime_type, data));
+}
+
+void ChromeToMobileReceiveBackend::DoOnPrintToPhoneJobDownloadComplete(
+      const std::string& job_id,
+      const bool& success,
+      const std::string& data_mime_type,
+      const std::string& data) {
+  DCHECK(MessageLoop::current() == frontend_loop_);
+  FOR_EACH_OBSERVER(
+      ChromeToMobileReceiveJobObserver, *frontend_->GetJobObservers(),
+      OnPrintToPhoneJobDownloadComplete(job_id, success, data_mime_type, data));
+}
+
+void ChromeToMobileReceiveBackend::HandleGetOAuth2AccessTokenFailure() {
+  DCHECK(MessageLoop::current() == chrome_to_mobile_thread_.message_loop());
+  PostToFrontendThread(base::Bind(
+      &ChromeToMobileReceiveFrontend::OnOAuth2AccessTokenFetchError,
+      base::Unretained(frontend_)));
+}
+
+void ChromeToMobileReceiveBackend::HandleCloudPrintAuthError() {
+  DCHECK(MessageLoop::current() == chrome_to_mobile_thread_.message_loop());
+  PostToFrontendThread(base::Bind(
+      &ChromeToMobileReceiveFrontend::OnCloudPrintAuthError,
+      base::Unretained(frontend_)));
+}
+
+void ChromeToMobileReceiveBackend::PostToChromeToMobileThread(
+    const base::Closure& task) {
+  chrome_to_mobile_thread_.message_loop()->PostTask(FROM_HERE, task);
+}
+
+void ChromeToMobileReceiveBackend::PostToFrontendThread(
+    const base::Closure& task) {
+  frontend_loop_->PostTask(FROM_HERE, task);
+}
+
+}  // namespace chrome_to_mobile_receive