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

   1 // Copyright 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/webui/local_discovery/local_discovery_ui_handler.h"
   6
   7 #include <set>
   8
   9 #include "base/bind.h"
  10 #include "base/command_line.h"
  11 #include "base/message_loop/message_loop.h"
  12 #include "base/prefs/pref_service.h"
  13 #include "base/strings/utf_string_conversions.h"
  14 #include "base/values.h"
  15 #include "chrome/browser/local_discovery/cloud_device_list.h"
  16 #include "chrome/browser/local_discovery/privet_confirm_api_flow.h"
  17 #include "chrome/browser/local_discovery/privet_constants.h"
  18 #include "chrome/browser/local_discovery/privet_device_lister_impl.h"
  19 #include "chrome/browser/local_discovery/privet_http_asynchronous_factory.h"
  20 #include "chrome/browser/local_discovery/service_discovery_shared_client.h"
  21 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service.h"
  22 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service_factory.h"
  23 #include "chrome/browser/profiles/profile.h"
  24 #include "chrome/browser/signin/profile_oauth2_token_service_factory.h"
  25 #include "chrome/browser/signin/signin_manager_factory.h"
  26 #include "chrome/browser/ui/browser_finder.h"
  27 #include "chrome/browser/ui/browser_tabstrip.h"
  28 #include "chrome/browser/ui/chrome_pages.h"
  29 #include "chrome/common/chrome_switches.h"
  30 #include "chrome/common/pref_names.h"
  31 #include "chrome/grit/generated_resources.h"
  32 #include "components/cloud_devices/common/cloud_devices_urls.h"
  33 #include "components/signin/core/browser/profile_oauth2_token_service.h"
  34 #include "content/public/browser/user_metrics.h"
  35 #include "content/public/browser/web_ui.h"
  36 #include "ui/base/l10n/l10n_util.h"
  37
  38 #if defined(ENABLE_PRINT_PREVIEW) && !defined(OS_CHROMEOS)
  39 #define CLOUD_PRINT_CONNECTOR_UI_AVAILABLE
  40 #endif
  41
  42 namespace local_discovery {
  43
  44 namespace {
  45
  46 const char kDictionaryKeyServiceName[] = "service_name";
  47 const char kDictionaryKeyDisplayName[] = "display_name";
  48 const char kDictionaryKeyDescription[] = "description";
  49 const char kDictionaryKeyType[] = "type";
  50 const char kDictionaryKeyIsWifi[] = "is_wifi";
  51 const char kDictionaryKeyID[] = "id";
  52
  53 const char kKeyPrefixMDns[] = "MDns:";
  54
  55 int g_num_visible = 0;
  56
  57 const int kCloudDevicesPrivetVersion = 3;
  58
  59 scoped_ptr<base::DictionaryValue> CreateDeviceInfo(
  60     const CloudDeviceListDelegate::Device& description) {
  61   scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
  62
  63   return_value->SetString(kDictionaryKeyID, description.id);
  64   return_value->SetString(kDictionaryKeyDisplayName, description.display_name);
  65   return_value->SetString(kDictionaryKeyDescription, description.description);
  66   return_value->SetString(kDictionaryKeyType, description.type);
  67
  68   return return_value.Pass();
  69 }
  70
  71 void ReadDevicesList(
  72     const std::vector<CloudDeviceListDelegate::Device>& devices,
  73     const std::set<std::string>& local_ids,
  74     base::ListValue* devices_list) {
  75   for (CloudDeviceList::iterator i = devices.begin(); i != devices.end(); i++) {
  76     if (local_ids.count(i->id) > 0) {
  77       devices_list->Append(CreateDeviceInfo(*i).release());
  78     }
  79   }
  80
  81   for (CloudDeviceList::iterator i = devices.begin(); i != devices.end(); i++) {
  82     if (local_ids.count(i->id) == 0) {
  83       devices_list->Append(CreateDeviceInfo(*i).release());
  84     }
  85   }
  86 }
  87
  88 }  // namespace
  89
  90 LocalDiscoveryUIHandler::LocalDiscoveryUIHandler()
  91     : is_visible_(false),
  92       failed_list_count_(0),
  93       succeded_list_count_(0) {
  94 #if defined(CLOUD_PRINT_CONNECTOR_UI_AVAILABLE)
  95 #if !defined(GOOGLE_CHROME_BUILD) && defined(OS_WIN)
  96   // On Windows, we need the PDF plugin which is only guaranteed to exist on
  97   // Google Chrome builds. Use a command-line switch for Windows non-Google
  98   //  Chrome builds.
  99   cloud_print_connector_ui_enabled_ =
 100       base::CommandLine::ForCurrentProcess()->HasSwitch(
 101           switches::kEnableCloudPrintProxy);
 102 #else
 103   // Always enabled for Linux and Google Chrome Windows builds.
 104   // Never enabled for Chrome OS, we don't even need to indicate it.
 105   cloud_print_connector_ui_enabled_ = true;
 106 #endif
 107 #endif  // defined(CLOUD_PRINT_CONNECTOR_UI_AVAILABLE)
 108 }
 109
 110 LocalDiscoveryUIHandler::~LocalDiscoveryUIHandler() {
 111   Profile* profile = Profile::FromWebUI(web_ui());
 112   SigninManagerBase* signin_manager =
 113       SigninManagerFactory::GetInstance()->GetForProfile(profile);
 114   if (signin_manager)
 115     signin_manager->RemoveObserver(this);
 116   ResetCurrentRegistration();
 117   SetIsVisible(false);
 118 }
 119
 120 // static
 121 bool LocalDiscoveryUIHandler::GetHasVisible() {
 122   return g_num_visible != 0;
 123 }
 124
 125 void LocalDiscoveryUIHandler::RegisterMessages() {
 126   web_ui()->RegisterMessageCallback("start", base::Bind(
 127       &LocalDiscoveryUIHandler::HandleStart,
 128       base::Unretained(this)));
 129   web_ui()->RegisterMessageCallback("isVisible", base::Bind(
 130       &LocalDiscoveryUIHandler::HandleIsVisible,
 131       base::Unretained(this)));
 132   web_ui()->RegisterMessageCallback("registerDevice", base::Bind(
 133       &LocalDiscoveryUIHandler::HandleRegisterDevice,
 134       base::Unretained(this)));
 135   web_ui()->RegisterMessageCallback("cancelRegistration", base::Bind(
 136       &LocalDiscoveryUIHandler::HandleCancelRegistration,
 137       base::Unretained(this)));
 138   web_ui()->RegisterMessageCallback(
 139       "requestDeviceList",
 140       base::Bind(&LocalDiscoveryUIHandler::HandleRequestDeviceList,
 141                  base::Unretained(this)));
 142   web_ui()->RegisterMessageCallback("openCloudPrintURL", base::Bind(
 143       &LocalDiscoveryUIHandler::HandleOpenCloudPrintURL,
 144       base::Unretained(this)));
 145   web_ui()->RegisterMessageCallback("showSyncUI", base::Bind(
 146       &LocalDiscoveryUIHandler::HandleShowSyncUI,
 147       base::Unretained(this)));
 148
 149   // Cloud print connector related messages
 150 #if defined(CLOUD_PRINT_CONNECTOR_UI_AVAILABLE)
 151   if (cloud_print_connector_ui_enabled_) {
 152     web_ui()->RegisterMessageCallback(
 153         "showCloudPrintSetupDialog",
 154         base::Bind(&LocalDiscoveryUIHandler::ShowCloudPrintSetupDialog,
 155                    base::Unretained(this)));
 156     web_ui()->RegisterMessageCallback(
 157         "disableCloudPrintConnector",
 158         base::Bind(&LocalDiscoveryUIHandler::HandleDisableCloudPrintConnector,
 159                    base::Unretained(this)));
 160   }
 161 #endif  // defined(CLOUD_PRINT_CONNECTOR_UI_AVAILABLE)
 162 }
 163
 164 void LocalDiscoveryUIHandler::HandleStart(const base::ListValue* args) {
 165   Profile* profile = Profile::FromWebUI(web_ui());
 166
 167   // If privet_lister_ is already set, it is a mock used for tests or the result
 168   // of a reload.
 169   if (!privet_lister_) {
 170     service_discovery_client_ = ServiceDiscoverySharedClient::GetInstance();
 171     privet_lister_.reset(
 172         new PrivetDeviceListerImpl(service_discovery_client_.get(), this));
 173     privet_http_factory_ = PrivetHTTPAsynchronousFactory::CreateInstance(
 174         profile->GetRequestContext());
 175
 176     SigninManagerBase* signin_manager =
 177         SigninManagerFactory::GetInstance()->GetForProfile(profile);
 178     if (signin_manager)
 179       signin_manager->AddObserver(this);
 180   }
 181
 182   privet_lister_->Start();
 183   privet_lister_->DiscoverNewDevices(false);
 184
 185 #if defined(CLOUD_PRINT_CONNECTOR_UI_AVAILABLE)
 186   StartCloudPrintConnector();
 187 #endif
 188
 189   CheckUserLoggedIn();
 190 }
 191
 192 void LocalDiscoveryUIHandler::HandleIsVisible(const base::ListValue* args) {
 193   bool is_visible = false;
 194   bool rv = args->GetBoolean(0, &is_visible);
 195   DCHECK(rv);
 196   SetIsVisible(is_visible);
 197 }
 198
 199 void LocalDiscoveryUIHandler::HandleRegisterDevice(
 200     const base::ListValue* args) {
 201   std::string device;
 202
 203   bool rv = args->GetString(0, &device);
 204   DCHECK(rv);
 205
 206   DeviceDescriptionMap::iterator found = device_descriptions_.find(device);
 207   if (found == device_descriptions_.end()) {
 208     OnSetupError();
 209     return;
 210   }
 211
 212   if (found->second.version < kCloudDevicesPrivetVersion) {
 213     privet_resolution_ = privet_http_factory_->CreatePrivetHTTP(device);
 214     privet_resolution_->Start(
 215         found->second.address,
 216         base::Bind(&LocalDiscoveryUIHandler::StartRegisterHTTP,
 217                    base::Unretained(this)));
 218   } else {
 219     OnSetupError();
 220   }
 221 }
 222
 223 void LocalDiscoveryUIHandler::HandleCancelRegistration(
 224     const base::ListValue* args) {
 225   ResetCurrentRegistration();
 226 }
 227
 228 void LocalDiscoveryUIHandler::HandleRequestDeviceList(
 229     const base::ListValue* args) {
 230   failed_list_count_ = 0;
 231   succeded_list_count_ = 0;
 232   cloud_devices_.clear();
 233
 234   cloud_print_printer_list_ = CreateApiFlow();
 235
 236   if (cloud_print_printer_list_) {
 237     cloud_print_printer_list_->Start(
 238         make_scoped_ptr<GCDApiFlow::Request>(new CloudPrintPrinterList(this)));
 239   }
 240
 241   CheckListingDone();
 242 }
 243
 244 void LocalDiscoveryUIHandler::HandleOpenCloudPrintURL(
 245     const base::ListValue* args) {
 246   std::string id;
 247   bool rv = args->GetString(0, &id);
 248   DCHECK(rv);
 249
 250   Browser* browser = chrome::FindBrowserWithWebContents(
 251       web_ui()->GetWebContents());
 252   DCHECK(browser);
 253
 254   chrome::AddSelectedTabWithURL(browser,
 255                                 cloud_devices::GetCloudPrintManageDeviceURL(id),
 256                                 ui::PAGE_TRANSITION_FROM_API);
 257 }
 258
 259 void LocalDiscoveryUIHandler::HandleShowSyncUI(
 260     const base::ListValue* args) {
 261   Browser* browser = chrome::FindBrowserWithWebContents(
 262       web_ui()->GetWebContents());
 263   DCHECK(browser);
 264   chrome::ShowBrowserSignin(browser, signin_metrics::SOURCE_DEVICES_PAGE);
 265 }
 266
 267 void LocalDiscoveryUIHandler::StartRegisterHTTP(
 268     scoped_ptr<PrivetHTTPClient> http_client) {
 269   current_http_client_ = PrivetV1HTTPClient::CreateDefault(http_client.Pass());
 270
 271   std::string user = GetSyncAccount();
 272
 273   if (!current_http_client_) {
 274     SendRegisterError();
 275     return;
 276   }
 277
 278   current_register_operation_ =
 279       current_http_client_->CreateRegisterOperation(user, this);
 280   current_register_operation_->Start();
 281 }
 282
 283 void LocalDiscoveryUIHandler::OnPrivetRegisterClaimToken(
 284     PrivetRegisterOperation* operation,
 285     const std::string& token,
 286     const GURL& url) {
 287   web_ui()->CallJavascriptFunction(
 288       "local_discovery.onRegistrationConfirmedOnPrinter");
 289   if (device_descriptions_.count(current_http_client_->GetName()) == 0) {
 290     SendRegisterError();
 291     return;
 292   }
 293
 294   confirm_api_call_flow_ = CreateApiFlow();
 295   if (!confirm_api_call_flow_) {
 296     SendRegisterError();
 297     return;
 298   }
 299   confirm_api_call_flow_->Start(
 300       make_scoped_ptr<GCDApiFlow::Request>(new PrivetConfirmApiCallFlow(
 301           token,
 302           base::Bind(&LocalDiscoveryUIHandler::OnConfirmDone,
 303                      base::Unretained(this)))));
 304 }
 305
 306 void LocalDiscoveryUIHandler::OnPrivetRegisterError(
 307     PrivetRegisterOperation* operation,
 308     const std::string& action,
 309     PrivetRegisterOperation::FailureReason reason,
 310     int printer_http_code,
 311     const base::DictionaryValue* json) {
 312   std::string error;
 313
 314   if (reason == PrivetRegisterOperation::FAILURE_JSON_ERROR &&
 315       json->GetString(kPrivetKeyError, &error)) {
 316     if (error == kPrivetErrorTimeout) {
 317         web_ui()->CallJavascriptFunction(
 318             "local_discovery.onRegistrationTimeout");
 319       return;
 320     } else if (error == kPrivetErrorCancel) {
 321       web_ui()->CallJavascriptFunction(
 322             "local_discovery.onRegistrationCanceledPrinter");
 323       return;
 324     }
 325   }
 326
 327   SendRegisterError();
 328 }
 329
 330 void LocalDiscoveryUIHandler::OnPrivetRegisterDone(
 331     PrivetRegisterOperation* operation,
 332     const std::string& device_id) {
 333   std::string name = operation->GetHTTPClient()->GetName();
 334   current_register_operation_.reset();
 335   current_http_client_.reset();
 336   SendRegisterDone(name);
 337 }
 338
 339 void LocalDiscoveryUIHandler::OnSetupError() {
 340   ResetCurrentRegistration();
 341   SendRegisterError();
 342 }
 343
 344 void LocalDiscoveryUIHandler::OnConfirmDone(GCDApiFlow::Status status) {
 345   if (status == GCDApiFlow::SUCCESS) {
 346     confirm_api_call_flow_.reset();
 347     current_register_operation_->CompleteRegistration();
 348   } else {
 349     SendRegisterError();
 350   }
 351 }
 352
 353 void LocalDiscoveryUIHandler::DeviceChanged(
 354     bool added,
 355     const std::string& name,
 356     const DeviceDescription& description) {
 357   device_descriptions_[name] = description;
 358
 359   base::DictionaryValue info;
 360
 361   base::StringValue service_key(kKeyPrefixMDns + name);
 362
 363   if (description.id.empty()) {
 364     info.SetString(kDictionaryKeyServiceName, name);
 365     info.SetString(kDictionaryKeyDisplayName, description.name);
 366     info.SetString(kDictionaryKeyDescription, description.description);
 367     info.SetString(kDictionaryKeyType, description.type);
 368     info.SetBoolean(kDictionaryKeyIsWifi, false);
 369
 370     web_ui()->CallJavascriptFunction(
 371         "local_discovery.onUnregisteredDeviceUpdate", service_key, info);
 372   } else {
 373     scoped_ptr<base::Value> null_value = base::Value::CreateNullValue();
 374
 375     web_ui()->CallJavascriptFunction(
 376         "local_discovery.onUnregisteredDeviceUpdate", service_key, *null_value);
 377   }
 378 }
 379
 380 void LocalDiscoveryUIHandler::DeviceRemoved(const std::string& name) {
 381   device_descriptions_.erase(name);
 382   scoped_ptr<base::Value> null_value = base::Value::CreateNullValue();
 383   base::StringValue name_value(kKeyPrefixMDns + name);
 384
 385   web_ui()->CallJavascriptFunction("local_discovery.onUnregisteredDeviceUpdate",
 386                                    name_value, *null_value);
 387 }
 388
 389 void LocalDiscoveryUIHandler::DeviceCacheFlushed() {
 390   web_ui()->CallJavascriptFunction("local_discovery.onDeviceCacheFlushed");
 391   privet_lister_->DiscoverNewDevices(false);
 392 }
 393
 394 void LocalDiscoveryUIHandler::OnDeviceListReady(
 395     const std::vector<Device>& devices) {
 396   cloud_devices_.insert(cloud_devices_.end(), devices.begin(), devices.end());
 397   ++succeded_list_count_;
 398   CheckListingDone();
 399 }
 400
 401 void LocalDiscoveryUIHandler::OnDeviceListUnavailable() {
 402   ++failed_list_count_;
 403   CheckListingDone();
 404 }
 405
 406 void LocalDiscoveryUIHandler::GoogleSigninSucceeded(
 407     const std::string& account_id,
 408     const std::string& username,
 409     const std::string& password) {
 410   CheckUserLoggedIn();
 411 }
 412
 413 void LocalDiscoveryUIHandler::GoogleSignedOut(const std::string& account_id,
 414                                               const std::string& username) {
 415   CheckUserLoggedIn();
 416 }
 417
 418 void LocalDiscoveryUIHandler::SendRegisterError() {
 419   web_ui()->CallJavascriptFunction("local_discovery.onRegistrationFailed");
 420 }
 421
 422 void LocalDiscoveryUIHandler::SendRegisterDone(
 423     const std::string& service_name) {
 424   // HACK(noamsml): Generate network traffic so the Windows firewall doesn't
 425   // block the printer's announcement.
 426   privet_lister_->DiscoverNewDevices(false);
 427
 428   DeviceDescriptionMap::iterator found =
 429       device_descriptions_.find(service_name);
 430
 431   if (found == device_descriptions_.end()) {
 432     // TODO(noamsml): Handle the case where a printer's record is not present at
 433     // the end of registration.
 434     SendRegisterError();
 435     return;
 436   }
 437
 438   const DeviceDescription& device = found->second;
 439   base::DictionaryValue device_value;
 440
 441   device_value.SetString(kDictionaryKeyType, device.type);
 442   device_value.SetString(kDictionaryKeyID, device.id);
 443   device_value.SetString(kDictionaryKeyDisplayName, device.name);
 444   device_value.SetString(kDictionaryKeyDescription, device.description);
 445   device_value.SetString(kDictionaryKeyServiceName, service_name);
 446
 447   web_ui()->CallJavascriptFunction("local_discovery.onRegistrationSuccess",
 448                                    device_value);
 449 }
 450
 451 void LocalDiscoveryUIHandler::SetIsVisible(bool visible) {
 452   if (visible != is_visible_) {
 453     g_num_visible += visible ? 1 : -1;
 454     is_visible_ = visible;
 455   }
 456 }
 457
 458 std::string LocalDiscoveryUIHandler::GetSyncAccount() {
 459   Profile* profile = Profile::FromWebUI(web_ui());
 460   SigninManagerBase* signin_manager =
 461       SigninManagerFactory::GetForProfileIfExists(profile);
 462
 463   if (!signin_manager) {
 464     return "";
 465   }
 466
 467   return signin_manager->GetAuthenticatedUsername();
 468 }
 469
 470 // TODO(noamsml): Create master object for registration flow.
 471 void LocalDiscoveryUIHandler::ResetCurrentRegistration() {
 472   if (current_register_operation_) {
 473     current_register_operation_->Cancel();
 474     current_register_operation_.reset();
 475   }
 476
 477   confirm_api_call_flow_.reset();
 478   privet_resolution_.reset();
 479   current_http_client_.reset();
 480 }
 481
 482 void LocalDiscoveryUIHandler::CheckUserLoggedIn() {
 483   base::FundamentalValue logged_in_value(!GetSyncAccount().empty());
 484   base::FundamentalValue is_supervised_value(IsUserSupervisedOrOffTheRecord());
 485   web_ui()->CallJavascriptFunction(
 486       "local_discovery.setUserLoggedIn", logged_in_value, is_supervised_value);
 487 }
 488
 489 void LocalDiscoveryUIHandler::CheckListingDone() {
 490   int started = 0;
 491   if (cloud_print_printer_list_)
 492     ++started;
 493
 494   if (started > failed_list_count_ + succeded_list_count_)
 495     return;
 496
 497   if (succeded_list_count_ <= 0) {
 498     web_ui()->CallJavascriptFunction(
 499         "local_discovery.onCloudDeviceListUnavailable");
 500     return;
 501   }
 502
 503   base::ListValue devices_list;
 504   std::set<std::string> local_ids;
 505
 506   for (DeviceDescriptionMap::iterator i = device_descriptions_.begin();
 507        i != device_descriptions_.end(); i++) {
 508     local_ids.insert(i->second.id);
 509   }
 510
 511   ReadDevicesList(cloud_devices_, local_ids, &devices_list);
 512
 513   web_ui()->CallJavascriptFunction(
 514       "local_discovery.onCloudDeviceListAvailable", devices_list);
 515   cloud_print_printer_list_.reset();
 516 }
 517
 518 scoped_ptr<GCDApiFlow> LocalDiscoveryUIHandler::CreateApiFlow() {
 519   Profile* profile = Profile::FromWebUI(web_ui());
 520   if (!profile)
 521     return scoped_ptr<GCDApiFlow>();
 522   ProfileOAuth2TokenService* token_service =
 523       ProfileOAuth2TokenServiceFactory::GetForProfile(profile);
 524   if (!token_service)
 525     return scoped_ptr<GCDApiFlow>();
 526   SigninManagerBase* signin_manager =
 527       SigninManagerFactory::GetInstance()->GetForProfile(profile);
 528   if (!signin_manager)
 529     return scoped_ptr<GCDApiFlow>();
 530   return GCDApiFlow::Create(profile->GetRequestContext(),
 531                             token_service,
 532                             signin_manager->GetAuthenticatedAccountId());
 533 }
 534
 535 bool LocalDiscoveryUIHandler::IsUserSupervisedOrOffTheRecord() {
 536   Profile* profile = Profile::FromWebUI(web_ui());
 537
 538   return profile->IsSupervised() || profile->IsOffTheRecord();
 539 }
 540
 541 #if defined(CLOUD_PRINT_CONNECTOR_UI_AVAILABLE)
 542 void LocalDiscoveryUIHandler::StartCloudPrintConnector() {
 543   Profile* profile = Profile::FromWebUI(web_ui());
 544
 545   base::Closure cloud_print_callback = base::Bind(
 546       &LocalDiscoveryUIHandler::OnCloudPrintPrefsChanged,
 547           base::Unretained(this));
 548
 549   if (cloud_print_connector_email_.GetPrefName().empty()) {
 550     cloud_print_connector_email_.Init(
 551         prefs::kCloudPrintEmail, profile->GetPrefs(), cloud_print_callback);
 552   }
 553
 554   if (cloud_print_connector_enabled_.GetPrefName().empty()) {
 555     cloud_print_connector_enabled_.Init(
 556         prefs::kCloudPrintProxyEnabled, profile->GetPrefs(),
 557         cloud_print_callback);
 558   }
 559
 560   if (cloud_print_connector_ui_enabled_) {
 561     SetupCloudPrintConnectorSection();
 562     RefreshCloudPrintStatusFromService();
 563   } else {
 564     RemoveCloudPrintConnectorSection();
 565   }
 566 }
 567
 568 void LocalDiscoveryUIHandler::OnCloudPrintPrefsChanged() {
 569   if (cloud_print_connector_ui_enabled_)
 570     SetupCloudPrintConnectorSection();
 571 }
 572
 573 void LocalDiscoveryUIHandler::ShowCloudPrintSetupDialog(
 574     const base::ListValue* args) {
 575   content::RecordAction(
 576       base::UserMetricsAction("Options_EnableCloudPrintProxy"));
 577   // Open the connector enable page in the current tab.
 578   Profile* profile = Profile::FromWebUI(web_ui());
 579   content::OpenURLParams params(
 580       cloud_devices::GetCloudPrintEnableURL(
 581           CloudPrintProxyServiceFactory::GetForProfile(profile)->proxy_id()),
 582       content::Referrer(),
 583       CURRENT_TAB,
 584       ui::PAGE_TRANSITION_LINK,
 585       false);
 586   web_ui()->GetWebContents()->OpenURL(params);
 587 }
 588
 589 void LocalDiscoveryUIHandler::HandleDisableCloudPrintConnector(
 590     const base::ListValue* args) {
 591   content::RecordAction(
 592       base::UserMetricsAction("Options_DisableCloudPrintProxy"));
 593   CloudPrintProxyServiceFactory::GetForProfile(Profile::FromWebUI(web_ui()))->
 594       DisableForUser();
 595 }
 596
 597 void LocalDiscoveryUIHandler::SetupCloudPrintConnectorSection() {
 598   Profile* profile = Profile::FromWebUI(web_ui());
 599
 600   if (!CloudPrintProxyServiceFactory::GetForProfile(profile)) {
 601     cloud_print_connector_ui_enabled_ = false;
 602     RemoveCloudPrintConnectorSection();
 603     return;
 604   }
 605
 606   bool cloud_print_connector_allowed =
 607       !cloud_print_connector_enabled_.IsManaged() ||
 608       cloud_print_connector_enabled_.GetValue();
 609   base::FundamentalValue allowed(cloud_print_connector_allowed);
 610
 611   std::string email;
 612   if (profile->GetPrefs()->HasPrefPath(prefs::kCloudPrintEmail) &&
 613       cloud_print_connector_allowed) {
 614     email = profile->GetPrefs()->GetString(prefs::kCloudPrintEmail);
 615   }
 616   base::FundamentalValue disabled(email.empty());
 617
 618   base::string16 label_str;
 619   if (email.empty()) {
 620     label_str = l10n_util::GetStringFUTF16(
 621         IDS_LOCAL_DISCOVERY_CLOUD_PRINT_CONNECTOR_DISABLED_LABEL,
 622         l10n_util::GetStringUTF16(IDS_GOOGLE_CLOUD_PRINT));
 623   } else {
 624     label_str = l10n_util::GetStringFUTF16(
 625         IDS_OPTIONS_CLOUD_PRINT_CONNECTOR_ENABLED_LABEL,
 626         l10n_util::GetStringUTF16(IDS_GOOGLE_CLOUD_PRINT),
 627         base::UTF8ToUTF16(email));
 628   }
 629   base::StringValue label(label_str);
 630
 631   web_ui()->CallJavascriptFunction(
 632       "local_discovery.setupCloudPrintConnectorSection", disabled, label,
 633       allowed);
 634 }
 635
 636 void LocalDiscoveryUIHandler::RemoveCloudPrintConnectorSection() {
 637   web_ui()->CallJavascriptFunction(
 638       "local_discovery.removeCloudPrintConnectorSection");
 639 }
 640
 641 void LocalDiscoveryUIHandler::RefreshCloudPrintStatusFromService() {
 642   if (cloud_print_connector_ui_enabled_)
 643     CloudPrintProxyServiceFactory::GetForProfile(Profile::FromWebUI(web_ui()))->
 644         RefreshStatusFromService();
 645 }
 646
 647 #endif // cloud print connector option stuff
 648
 649 }  // namespace local_discovery