src/chrome/browser/ui/webui/ntp/new_tab_page_sync_handler.cc

   1 // Copyright (c) 2012 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/ntp/new_tab_page_sync_handler.h"
   6
   7 #include <vector>
   8
   9 #include "base/bind.h"
  10 #include "base/bind_helpers.h"
  11 #include "base/prefs/pref_service.h"
  12 #include "base/strings/string_split.h"
  13 #include "base/strings/string_util.h"
  14 #include "base/strings/utf_string_conversions.h"
  15 #include "base/values.h"
  16 #include "chrome/browser/net/chrome_url_request_context.h"
  17 #include "chrome/browser/profiles/profile.h"
  18 #include "chrome/browser/signin/signin_manager.h"
  19 #include "chrome/browser/signin/signin_manager_factory.h"
  20 #include "chrome/browser/signin/signin_promo.h"
  21 #include "chrome/browser/sync/profile_sync_service.h"
  22 #include "chrome/browser/sync/profile_sync_service_factory.h"
  23 #include "chrome/browser/ui/browser.h"
  24 #include "chrome/browser/ui/browser_finder.h"
  25 #include "chrome/browser/ui/chrome_pages.h"
  26 #include "chrome/browser/ui/webui/signin/login_ui_service.h"
  27 #include "chrome/browser/ui/webui/signin/login_ui_service_factory.h"
  28 #include "chrome/common/pref_names.h"
  29 #include "content/public/browser/render_view_host.h"
  30 #include "content/public/browser/web_ui.h"
  31 #include "grit/generated_resources.h"
  32 #include "net/cookies/cookie_monster.h"
  33 #include "net/url_request/url_request_context.h"
  34 #include "ui/base/l10n/l10n_util.h"
  35
  36 NewTabPageSyncHandler::NewTabPageSyncHandler() : sync_service_(NULL),
  37   waiting_for_initial_page_load_(true) {
  38 }
  39
  40 NewTabPageSyncHandler::~NewTabPageSyncHandler() {
  41   if (sync_service_)
  42     sync_service_->RemoveObserver(this);
  43 }
  44
  45 // static
  46 NewTabPageSyncHandler::MessageType
  47     NewTabPageSyncHandler::FromSyncStatusMessageType(
  48         sync_ui_util::MessageType type) {
  49   switch (type) {
  50     case sync_ui_util::SYNC_ERROR:
  51       return SYNC_ERROR;
  52     case sync_ui_util::SYNC_PROMO:
  53       return SYNC_PROMO;
  54     case sync_ui_util::PRE_SYNCED:
  55     case sync_ui_util::SYNCED:
  56     default:
  57       return HIDE;
  58   }
  59 }
  60
  61 void NewTabPageSyncHandler::RegisterMessages() {
  62   sync_service_ = ProfileSyncServiceFactory::GetInstance()->GetForProfile(
  63       Profile::FromWebUI(web_ui()));
  64   if (sync_service_)
  65     sync_service_->AddObserver(this);
  66   profile_pref_registrar_.Init(Profile::FromWebUI(web_ui())->GetPrefs());
  67   profile_pref_registrar_.Add(
  68       prefs::kSigninAllowed,
  69       base::Bind(&NewTabPageSyncHandler::OnSigninAllowedPrefChange,
  70                  base::Unretained(this)));
  71
  72   web_ui()->RegisterMessageCallback("GetSyncMessage",
  73       base::Bind(&NewTabPageSyncHandler::HandleGetSyncMessage,
  74                  base::Unretained(this)));
  75   web_ui()->RegisterMessageCallback("SyncLinkClicked",
  76       base::Bind(&NewTabPageSyncHandler::HandleSyncLinkClicked,
  77                  base::Unretained(this)));
  78 }
  79
  80 void NewTabPageSyncHandler::HandleGetSyncMessage(const ListValue* args) {
  81   waiting_for_initial_page_load_ = false;
  82   BuildAndSendSyncStatus();
  83 }
  84
  85 void NewTabPageSyncHandler::HideSyncStatusSection() {
  86   SendSyncMessageToPage(HIDE, std::string(), std::string());
  87 }
  88
  89 void NewTabPageSyncHandler::BuildAndSendSyncStatus() {
  90   DCHECK(!waiting_for_initial_page_load_);
  91   SigninManagerBase* signin = SigninManagerFactory::GetForProfile(
  92       Profile::FromWebUI(web_ui()));
  93
  94   // Hide the sync status section if sync is managed or disabled entirely.
  95   if (!sync_service_ ||
  96       sync_service_->IsManaged() ||
  97       !signin ||
  98       !signin->IsSigninAllowed()) {
  99     HideSyncStatusSection();
 100     return;
 101   }
 102
 103   // Don't show sync status if setup is not complete.
 104   if (!sync_service_->HasSyncSetupCompleted()) {
 105     return;
 106   }
 107
 108   // Once sync has been enabled, the supported "sync statuses" for the NNTP
 109   // from the user's perspective are:
 110   //
 111   // "Sync error", when we can't authenticate or establish a connection with
 112   //               the sync server (appropriate information appended to
 113   //               message).
 114   string16 status_msg;
 115   string16 link_text;
 116
 117   sync_ui_util::MessageType type =
 118       sync_ui_util::GetStatusLabelsForNewTabPage(sync_service_,
 119                                                  *signin,
 120                                                  &status_msg,
 121                                                  &link_text);
 122   SendSyncMessageToPage(FromSyncStatusMessageType(type),
 123                         UTF16ToUTF8(status_msg), UTF16ToUTF8(link_text));
 124 }
 125
 126 void NewTabPageSyncHandler::HandleSyncLinkClicked(const ListValue* args) {
 127   DCHECK(!waiting_for_initial_page_load_);
 128   if (!sync_service_ || !sync_service_->IsSyncEnabled())
 129     return;
 130   Browser* browser =
 131       chrome::FindBrowserWithWebContents(web_ui()->GetWebContents());
 132   if (!browser || browser->IsAttemptingToCloseBrowser())
 133     return;
 134   chrome::ShowBrowserSignin(browser, signin::SOURCE_NTP_LINK);
 135
 136   if (sync_service_->HasSyncSetupCompleted()) {
 137     string16 user = UTF8ToUTF16(SigninManagerFactory::GetForProfile(
 138         Profile::FromWebUI(web_ui()))->GetAuthenticatedUsername());
 139     DictionaryValue value;
 140     value.SetString("syncEnabledMessage",
 141                     l10n_util::GetStringFUTF16(IDS_SYNC_NTP_SYNCED_TO,
 142                     user));
 143     web_ui()->CallJavascriptFunction("ntp.syncAlreadyEnabled", value);
 144   } else {
 145     ProfileSyncService::SyncEvent(ProfileSyncService::START_FROM_NTP);
 146   }
 147 }
 148
 149 void NewTabPageSyncHandler::OnStateChanged() {
 150   // Don't do anything if the page has not yet loaded.
 151   if (waiting_for_initial_page_load_)
 152     return;
 153   BuildAndSendSyncStatus();
 154 }
 155
 156 void NewTabPageSyncHandler::OnSigninAllowedPrefChange() {
 157   // Don't do anything if the page has not yet loaded.
 158   if (waiting_for_initial_page_load_)
 159     return;
 160   BuildAndSendSyncStatus();
 161 }
 162
 163 void NewTabPageSyncHandler::SendSyncMessageToPage(
 164     MessageType type, std::string msg,
 165     std::string linktext) {
 166   DictionaryValue value;
 167   std::string user;
 168   std::string title;
 169   std::string linkurl;
 170
 171   // If there is nothing to show, we should hide the sync section altogether.
 172   if (type == HIDE || (msg.empty() && linktext.empty())) {
 173     value.SetBoolean("syncsectionisvisible", false);
 174   } else {
 175     if (type == SYNC_ERROR)
 176       title = l10n_util::GetStringUTF8(IDS_SYNC_NTP_SYNC_SECTION_ERROR_TITLE);
 177     else if (type == SYNC_PROMO)
 178       title = l10n_util::GetStringUTF8(IDS_SYNC_NTP_SYNC_SECTION_PROMO_TITLE);
 179     else
 180       NOTREACHED();
 181
 182     value.SetBoolean("syncsectionisvisible", true);
 183     value.SetString("msg", msg);
 184     value.SetString("title", title);
 185     if (linktext.empty()) {
 186       value.SetBoolean("linkisvisible", false);
 187     } else {
 188       value.SetBoolean("linkisvisible", true);
 189       value.SetString("linktext", linktext);
 190
 191       // The only time we set the URL is when the user is synced and we need to
 192       // show a link to a web interface (e.g. http://docs.google.com). When we
 193       // set that URL, HandleSyncLinkClicked won't be called when the user
 194       // clicks on the link.
 195       if (linkurl.empty()) {
 196         value.SetBoolean("linkurlisset", false);
 197       } else {
 198         value.SetBoolean("linkurlisset", true);
 199         value.SetString("linkurl", linkurl);
 200       }
 201     }
 202   }
 203   web_ui()->CallJavascriptFunction("ntp.syncMessageChanged", value);
 204 }