Removed unused native code related to wifi bootstrapping.

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"
 #include "base/message_loop/message_loop.h"
 #include "base/prefs/pref_service.h"
-#include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
+#include "chrome/browser/local_discovery/cloud_device_list.h"
 #include "chrome/browser/local_discovery/privet_confirm_api_flow.h"
 #include "chrome/browser/local_discovery/privet_constants.h"
 #include "chrome/browser/local_discovery/privet_device_lister_impl.h"
 #include "chrome/browser/local_discovery/privet_http_asynchronous_factory.h"
-#include "chrome/browser/local_discovery/privet_http_impl.h"
 #include "chrome/browser/local_discovery/service_discovery_shared_client.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
 #include "chrome/browser/signin/signin_manager_factory.h"
-#include "chrome/browser/signin/signin_promo.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/chrome_pages.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/generated_resources.h"
-#include "components/cloud_devices/common/cloud_devices_switches.h"
 #include "components/cloud_devices/common/cloud_devices_urls.h"
 #include "components/signin/core/browser/profile_oauth2_token_service.h"
-#include "components/signin/core/browser/signin_manager_base.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_ui.h"
-#include "net/base/host_port_pair.h"
-#include "net/base/net_util.h"
-#include "net/base/url_util.h"
-#include "net/http/http_status_code.h"
 #include "ui/base/l10n/l10n_util.h"
-#include "ui/base/page_transition_types.h"
 
 #if defined(ENABLE_PRINT_PREVIEW) && !defined(OS_CHROMEOS)
 #define CLOUD_PRINT_CONNECTOR_UI_AVAILABLE
 #endif
 
 namespace local_discovery {
 
 namespace {
 
 const char kDictionaryKeyServiceName[] = "service_name";
 const char kDictionaryKeyDisplayName[] = "display_name";
 const char kDictionaryKeyDescription[] = "description";
 const char kDictionaryKeyType[] = "type";
 const char kDictionaryKeyIsWifi[] = "is_wifi";
 const char kDictionaryKeyID[] = "id";
 
 const char kKeyPrefixMDns[] = "MDns:";
 
-#if defined(ENABLE_WIFI_BOOTSTRAPPING)
-const char kKeyPrefixWifi[] = "WiFi:";
-#endif  // ENABLE_WIFI_BOOTSTRAPPING
-
 int g_num_visible = 0;
 
 const int kCloudDevicesPrivetVersion = 3;
 
 scoped_ptr<base::DictionaryValue> CreateDeviceInfo(
     const CloudDeviceListDelegate::Device& description) {
   scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
 
   return_value->SetString(kDictionaryKeyID, description.id);
   return_value->SetString(kDictionaryKeyDisplayName, description.display_name);
@@ skipping 60 matching lines @@
 void LocalDiscoveryUIHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback("start", base::Bind(
       &LocalDiscoveryUIHandler::HandleStart,
       base::Unretained(this)));
   web_ui()->RegisterMessageCallback("isVisible", base::Bind(
       &LocalDiscoveryUIHandler::HandleIsVisible,
       base::Unretained(this)));
   web_ui()->RegisterMessageCallback("registerDevice", base::Bind(
       &LocalDiscoveryUIHandler::HandleRegisterDevice,
       base::Unretained(this)));
-  web_ui()->RegisterMessageCallback(
-      "confirmCode",
-      base::Bind(&LocalDiscoveryUIHandler::HandleConfirmCode,
-                 base::Unretained(this)));
   web_ui()->RegisterMessageCallback("cancelRegistration", base::Bind(
       &LocalDiscoveryUIHandler::HandleCancelRegistration,
       base::Unretained(this)));
   web_ui()->RegisterMessageCallback(
       "requestDeviceList",
       base::Bind(&LocalDiscoveryUIHandler::HandleRequestDeviceList,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("openCloudPrintURL", base::Bind(
       &LocalDiscoveryUIHandler::HandleOpenCloudPrintURL,
       base::Unretained(this)));
@@ skipping 34 matching lines @@
       signin_manager->AddObserver(this);
   }
 
   privet_lister_->Start();
   privet_lister_->DiscoverNewDevices(false);
 
 #if defined(CLOUD_PRINT_CONNECTOR_UI_AVAILABLE)
   StartCloudPrintConnector();
 #endif
 
-#if defined(ENABLE_WIFI_BOOTSTRAPPING)
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableCloudDevices)) {
-    StartWifiBootstrapping();
-  }
-#endif
-
   CheckUserLoggedIn();
 }
 
 void LocalDiscoveryUIHandler::HandleIsVisible(const base::ListValue* args) {
   bool is_visible = false;
   bool rv = args->GetBoolean(0, &is_visible);
   DCHECK(rv);
   SetIsVisible(is_visible);
 }
 
 void LocalDiscoveryUIHandler::HandleRegisterDevice(
     const base::ListValue* args) {
   std::string device;
 
   bool rv = args->GetString(0, &device);
   DCHECK(rv);
 
   DeviceDescriptionMap::iterator found = device_descriptions_.find(device);
   if (found == device_descriptions_.end()) {
     OnSetupError();
     return;
   }
 
-  if (found->second.version == kCloudDevicesPrivetVersion) {
-    current_setup_operation_.reset(new PrivetV3SetupFlow(this));
-    current_setup_operation_->Register(device);
-  } else if (found->second.version <= 2) {
+  if (found->second.version < kCloudDevicesPrivetVersion) {
     privet_resolution_ = privet_http_factory_->CreatePrivetHTTP(
         device,
         found->second.address,
         base::Bind(&LocalDiscoveryUIHandler::StartRegisterHTTP,
                    base::Unretained(this)));
     privet_resolution_->Start();
   } else {
     OnSetupError();
   }
 }
 
-void LocalDiscoveryUIHandler::HandleConfirmCode(const base::ListValue* args) {
-  device_code_callback_.Run(true);
-}
-
 void LocalDiscoveryUIHandler::HandleCancelRegistration(
     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();
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableCloudDevices)) {
-    cloud_device_list_ = CreateApiFlow();
-  }
-
   if (cloud_print_printer_list_) {
     cloud_print_printer_list_->Start(
         make_scoped_ptr<GCDApiFlow::Request>(new CloudPrintPrinterList(this)));
   }
-  if (cloud_device_list_) {
-    cloud_device_list_->Start(
-        make_scoped_ptr<GCDApiFlow::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 73 matching lines @@
     }
   }
 
   SendRegisterError();
 }
 
 void LocalDiscoveryUIHandler::OnPrivetRegisterDone(
     PrivetRegisterOperation* operation,
     const std::string& device_id) {
   std::string name = operation->GetHTTPClient()->GetName();
-  current_setup_operation_.reset();
   current_register_operation_.reset();
   current_http_client_.reset();
   SendRegisterDone(name);
 }
 
-void LocalDiscoveryUIHandler::GetWiFiCredentials(
-    const CredentialsCallback& callback) {
-  callback.Run("", "");
-}
-
-void LocalDiscoveryUIHandler::SwitchToSetupWiFi(
-    const ResultCallback& callback) {
-  callback.Run(true);
-}
-
-void LocalDiscoveryUIHandler::ConfirmSecurityCode(
-    const ResultCallback& callback) {
-  device_code_callback_ = callback;
-  web_ui()->CallJavascriptFunction(
-      "local_discovery.onRegistrationConfirmDeviceCode",
-      base::StringValue("1234"));
-}
-
-void LocalDiscoveryUIHandler::RestoreWifi(const ResultCallback& callback) {
-  callback.Run(true);
-}
-
-void LocalDiscoveryUIHandler::OnSetupDone() {
-  std::string service_name = current_setup_operation_->service_name();
-  current_setup_operation_.reset();
-  current_register_operation_.reset();
-  current_http_client_.reset();
-  SendRegisterDone(service_name);
-}
-
 void LocalDiscoveryUIHandler::OnSetupError() {
   ResetCurrentRegistration();
   SendRegisterError();
 }
 
 void LocalDiscoveryUIHandler::OnConfirmDone(GCDApiFlow::Status status) {
   if (status == GCDApiFlow::SUCCESS) {
     confirm_api_call_flow_.reset();
     current_register_operation_->CompleteRegistration();
   } else {
@@ skipping 118 matching lines @@
   return signin_manager->GetAuthenticatedUsername();
 }
 
 // TODO(noamsml): Create master object for registration flow.
 void LocalDiscoveryUIHandler::ResetCurrentRegistration() {
   if (current_register_operation_) {
     current_register_operation_->Cancel();
     current_register_operation_.reset();
   }
 
-  current_setup_operation_.reset();
   confirm_api_call_flow_.reset();
   privet_resolution_.reset();
   current_http_client_.reset();
 }
 
-void LocalDiscoveryUIHandler::PrivetClientToV3(
-    const PrivetClientCallback& callback,
-    scoped_ptr<PrivetHTTPClient> client) {
-  callback.Run(client.Pass());
-}
-
 void LocalDiscoveryUIHandler::CheckUserLoggedIn() {
   base::FundamentalValue logged_in_value(!GetSyncAccount().empty());
   base::FundamentalValue is_supervised_value(IsUserSupervisedOrOffTheRecord());
   web_ui()->CallJavascriptFunction(
       "local_discovery.setUserLoggedIn", logged_in_value, is_supervised_value);
 }
 
 void LocalDiscoveryUIHandler::CheckListingDone() {
   int started = 0;
   if (cloud_print_printer_list_)
     ++started;
-  if (cloud_device_list_)
-    ++started;
 
   if (started > failed_list_count_ + succeded_list_count_)
     return;
 
   if (succeded_list_count_ <= 0) {
     web_ui()->CallJavascriptFunction(
         "local_discovery.onCloudDeviceListUnavailable");
     return;
   }
 
   base::ListValue devices_list;
   std::set<std::string> local_ids;
 
   for (DeviceDescriptionMap::iterator i = device_descriptions_.begin();
        i != device_descriptions_.end(); i++) {
     local_ids.insert(i->second.id);
   }
 
   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() {
   Profile* profile = Profile::FromWebUI(web_ui());
   if (!profile)
     return scoped_ptr<GCDApiFlow>();
   ProfileOAuth2TokenService* token_service =
       ProfileOAuth2TokenServiceFactory::GetForProfile(profile);
   if (!token_service)
     return scoped_ptr<GCDApiFlow>();
   SigninManagerBase* signin_manager =
       SigninManagerFactory::GetInstance()->GetForProfile(profile);
   if (!signin_manager)
     return scoped_ptr<GCDApiFlow>();
   return GCDApiFlow::Create(profile->GetRequestContext(),
                             token_service,
                             signin_manager->GetAuthenticatedAccountId());
 }
 
-void LocalDiscoveryUIHandler::CreatePrivetV3Client(
-    const std::string& device,
-    const PrivetClientCallback& callback) {
-  DeviceDescriptionMap::iterator found = device_descriptions_.find(device);
-  if (found == device_descriptions_.end())
-    return callback.Run(scoped_ptr<PrivetHTTPClient>());
-  PrivetHTTPAsynchronousFactory::ResultCallback new_callback =
-      base::Bind(&LocalDiscoveryUIHandler::PrivetClientToV3,
-                 base::Unretained(this),
-                 callback);
-  privet_resolution_ =
-      privet_http_factory_->CreatePrivetHTTP(device,
-                                             found->second.address,
-                                             new_callback).Pass();
-  if (!privet_resolution_)
-    return callback.Run(scoped_ptr<PrivetHTTPClient>());
-  privet_resolution_->Start();
-}
-
 bool LocalDiscoveryUIHandler::IsUserSupervisedOrOffTheRecord() {
   Profile* profile = Profile::FromWebUI(web_ui());
 
   return profile->IsSupervised() || profile->IsOffTheRecord();
 }
 
 #if defined(CLOUD_PRINT_CONNECTOR_UI_AVAILABLE)
 void LocalDiscoveryUIHandler::StartCloudPrintConnector() {
   Profile* profile = Profile::FromWebUI(web_ui());
 
@@ skipping 94 matching lines @@
 }
 
 void LocalDiscoveryUIHandler::RefreshCloudPrintStatusFromService() {
   if (cloud_print_connector_ui_enabled_)
     CloudPrintProxyServiceFactory::GetForProfile(Profile::FromWebUI(web_ui()))->
         RefreshStatusFromService();
 }
 
 #endif // cloud print connector option stuff
 
-#if defined(ENABLE_WIFI_BOOTSTRAPPING)
-
-void LocalDiscoveryUIHandler::StartWifiBootstrapping() {
-  // Since LocalDiscoveryUIHandler isn't destroyed every time the page is
-  // refreshed, reset bootstrapping_device_lister_ so it's destoryed before
-  // wifi_manager_ is.
-  bootstrapping_device_lister_.reset();
-
-  wifi_manager_ = wifi::WifiManager::Create();
-  bootstrapping_device_lister_.reset(new wifi::BootstrappingDeviceLister(
-      wifi_manager_.get(),
-      base::Bind(&LocalDiscoveryUIHandler::OnBootstrappingDeviceChanged,
-                 base::Unretained(this))));
-
-  wifi_manager_->Start();
-  bootstrapping_device_lister_->Start();
-  wifi_manager_->RequestScan();
-}
-
-void LocalDiscoveryUIHandler::OnBootstrappingDeviceChanged(
-    bool available,
-    const wifi::BootstrappingDeviceDescription& description) {
-  base::DictionaryValue info;
-
-  base::StringValue service_key(kKeyPrefixWifi + description.device_ssid);
-
-  if (available) {
-    info.SetString(kDictionaryKeyServiceName, description.device_ssid);
-    info.SetString(kDictionaryKeyDisplayName, description.device_name);
-    info.SetString(kDictionaryKeyDescription, std::string());
-    info.SetString(kDictionaryKeyType, description.device_kind);
-    info.SetBoolean(kDictionaryKeyIsWifi, true);
-
-    web_ui()->CallJavascriptFunction(
-        "local_discovery.onUnregisteredDeviceUpdate", service_key, info);
-  } else {
-    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