Added new GCD/Privet interfaces.

chrome/browser/ui/webui/local_discovery/local_discovery_ui_handler.cc

 // Copyright 2013 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/ui/webui/local_discovery/local_discovery_ui_handler.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 221 matching lines @@
     const base::ListValue* args) {
   ResetCurrentRegistration();
 }
 
 void LocalDiscoveryUIHandler::HandleRequestDeviceList(
     const base::ListValue* args) {
   failed_list_count_ = 0;
   succeded_list_count_ = 0;
   cloud_devices_.clear();
 
-  cloud_print_printer_list_ = CreateApiFlow(
-      scoped_ptr<GCDApiFlow::Request>(new CloudPrintPrinterList(this)));
+  cloud_print_printer_list_ = CreateApiFlow();
   if (CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kEnableCloudDevices)) {
-    cloud_device_list_ = CreateApiFlow(
-        scoped_ptr<GCDApiFlow::Request>(new CloudDeviceList(this)));
+    cloud_device_list_ = CreateApiFlow();
   }
 
-  if (cloud_print_printer_list_)
-    cloud_print_printer_list_->Start();
-  if (cloud_device_list_)
-    cloud_device_list_->Start();
+  if (cloud_print_printer_list_) {
+    cloud_print_printer_list_->Start(
+        make_scoped_ptr<GCDApiFlowInterface::Request>(
+            new CloudPrintPrinterList(this)));
+  }
+  if (cloud_device_list_) {
+    cloud_device_list_->Start(make_scoped_ptr<GCDApiFlowInterface::Request>(
+        new CloudDeviceList(this)));
+  }
   CheckListingDone();
 }
 
 void LocalDiscoveryUIHandler::HandleOpenCloudPrintURL(
     const base::ListValue* args) {
   std::string id;
   bool rv = args->GetString(0, &id);
   DCHECK(rv);
 
   Browser* browser = chrome::FindBrowserWithWebContents(
@@ skipping 39 matching lines @@
     PrivetRegisterOperation* operation,
     const std::string& token,
     const GURL& url) {
   web_ui()->CallJavascriptFunction(
       "local_discovery.onRegistrationConfirmedOnPrinter");
   if (device_descriptions_.count(current_http_client_->GetName()) == 0) {
     SendRegisterError();
     return;
   }
 
-  confirm_api_call_flow_ = CreateApiFlow(
-      scoped_ptr<GCDApiFlow::Request>(new PrivetConfirmApiCallFlow(
-          token,
-          base::Bind(&LocalDiscoveryUIHandler::OnConfirmDone,
-                     base::Unretained(this)))));
+  confirm_api_call_flow_ = CreateApiFlow();
   if (!confirm_api_call_flow_) {
     SendRegisterError();
     return;
   }
-  confirm_api_call_flow_->Start();
+  confirm_api_call_flow_->Start(make_scoped_ptr<GCDApiFlowInterface::Request>(
+      new PrivetConfirmApiCallFlow(
+          token,
+          base::Bind(&LocalDiscoveryUIHandler::OnConfirmDone,
+                     base::Unretained(this)))));
 }
 
 void LocalDiscoveryUIHandler::OnPrivetRegisterError(
     PrivetRegisterOperation* operation,
     const std::string& action,
     PrivetRegisterOperation::FailureReason reason,
     int printer_http_code,
     const base::DictionaryValue* json) {
   std::string error;
 
@@ skipping 140 matching lines @@
 
   if (!signin_manager) {
     return "";
   }
 
   return signin_manager->GetAuthenticatedUsername();
 }
 
 // TODO(noamsml): Create master object for registration flow.
 void LocalDiscoveryUIHandler::ResetCurrentRegistration() {
-  if (current_register_operation_.get()) {
+  if (current_register_operation_) {
     current_register_operation_->Cancel();
     current_register_operation_.reset();
   }
 
   confirm_api_call_flow_.reset();
   privet_resolution_.reset();
   current_http_client_.reset();
 }
 
 void LocalDiscoveryUIHandler::CheckUserLoggedIn() {
@@ skipping 27 matching lines @@
   }
 
   ReadDevicesList(cloud_devices_, local_ids, &devices_list);
 
   web_ui()->CallJavascriptFunction(
       "local_discovery.onCloudDeviceListAvailable", devices_list);
   cloud_print_printer_list_.reset();
   cloud_device_list_.reset();
 }
 
-scoped_ptr<GCDApiFlow> LocalDiscoveryUIHandler::CreateApiFlow(
-    scoped_ptr<GCDApiFlow::Request> request) {
+scoped_ptr<GCDApiFlowInterface> LocalDiscoveryUIHandler::CreateApiFlow() {
   Profile* profile = Profile::FromWebUI(web_ui());
   if (!profile)
-    return scoped_ptr<GCDApiFlow>();
+    return scoped_ptr<GCDApiFlowInterface>();
   ProfileOAuth2TokenService* token_service =
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile);
   if (!token_service)
-    return scoped_ptr<GCDApiFlow>();
+    return scoped_ptr<GCDApiFlowInterface>();
   SigninManagerBase* signin_manager =
       SigninManagerFactory::GetInstance()->GetForProfile(profile);
   if (!signin_manager)
-    return scoped_ptr<GCDApiFlow>();
-  return make_scoped_ptr(
+    return scoped_ptr<GCDApiFlowInterface>();
+  return make_scoped_ptr<GCDApiFlowInterface>(
       new GCDApiFlow(profile->GetRequestContext(),
                      token_service,
-                     signin_manager->GetAuthenticatedAccountId(),
-                     request.Pass()));
+                     signin_manager->GetAuthenticatedAccountId()));
 }
 
 #if defined(CLOUD_PRINT_CONNECTOR_UI_AVAILABLE)
 void LocalDiscoveryUIHandler::StartCloudPrintConnector() {
   Profile* profile = Profile::FromWebUI(web_ui());
 
   base::Closure cloud_print_callback = base::Bind(
       &LocalDiscoveryUIHandler::OnCloudPrintPrefsChanged,
           base::Unretained(this));
 
@@ skipping 136 matching lines @@
     scoped_ptr<base::Value> null_value(base::Value::CreateNullValue());
 
     web_ui()->CallJavascriptFunction(
         "local_discovery.onUnregisteredDeviceUpdate", service_key, *null_value);
   }
 }
 
 #endif  // ENABLE_WIFI_BOOTSTRAPPING
 
 }  // namespace local_discovery