Home | History | Annotate | Download | only in ntp 
      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/profiles/profile.h"
     17 #include "chrome/browser/signin/signin_manager_factory.h"
     18 #include "chrome/browser/signin/signin_promo.h"
     19 #include "chrome/browser/sync/profile_sync_service.h"
     20 #include "chrome/browser/sync/profile_sync_service_factory.h"
     21 #include "chrome/browser/ui/browser.h"
     22 #include "chrome/browser/ui/browser_finder.h"
     23 #include "chrome/browser/ui/chrome_pages.h"
     24 #include "chrome/browser/ui/webui/signin/login_ui_service.h"
     25 #include "chrome/browser/ui/webui/signin/login_ui_service_factory.h"
     26 #include "chrome/common/pref_names.h"
     27 #include "chrome/grit/generated_resources.h"
     28 #include "components/signin/core/browser/signin_manager.h"
     29 #include "content/public/browser/render_view_host.h"
     30 #include "content/public/browser/web_ui.h"
     31 #include "net/cookies/cookie_monster.h"
     32 #include "net/url_request/url_request_context.h"
     33 #include "ui/base/l10n/l10n_util.h"
     34 
     35 NewTabPageSyncHandler::NewTabPageSyncHandler() : sync_service_(NULL),
     36   waiting_for_initial_page_load_(true) {
     37 }
     38 
     39 NewTabPageSyncHandler::~NewTabPageSyncHandler() {
     40   if (sync_service_)
     41     sync_service_->RemoveObserver(this);
     42 }
     43 
     44 // static
     45 NewTabPageSyncHandler::MessageType
     46     NewTabPageSyncHandler::FromSyncStatusMessageType(
     47         sync_ui_util::MessageType type) {
     48   switch (type) {
     49     case sync_ui_util::SYNC_ERROR:
     50       return SYNC_ERROR;
     51     case sync_ui_util::SYNC_PROMO:
     52       return SYNC_PROMO;
     53     case sync_ui_util::PRE_SYNCED:
     54     case sync_ui_util::SYNCED:
     55     default:
     56       return HIDE;
     57   }
     58 }
     59 
     60 void NewTabPageSyncHandler::RegisterMessages() {
     61   sync_service_ = ProfileSyncServiceFactory::GetInstance()->GetForProfile(
     62       Profile::FromWebUI(web_ui()));
     63   if (sync_service_)
     64     sync_service_->AddObserver(this);
     65   profile_pref_registrar_.Init(Profile::FromWebUI(web_ui())->GetPrefs());
     66   profile_pref_registrar_.Add(
     67       prefs::kSigninAllowed,
     68       base::Bind(&NewTabPageSyncHandler::OnSigninAllowedPrefChange,
     69                  base::Unretained(this)));
     70 
     71   web_ui()->RegisterMessageCallback("GetSyncMessage",
     72       base::Bind(&NewTabPageSyncHandler::HandleGetSyncMessage,
     73                  base::Unretained(this)));
     74   web_ui()->RegisterMessageCallback("SyncLinkClicked",
     75       base::Bind(&NewTabPageSyncHandler::HandleSyncLinkClicked,
     76                  base::Unretained(this)));
     77 }
     78 
     79 void NewTabPageSyncHandler::HandleGetSyncMessage(const base::ListValue* args) {
     80   waiting_for_initial_page_load_ = false;
     81   BuildAndSendSyncStatus();
     82 }
     83 
     84 void NewTabPageSyncHandler::HideSyncStatusSection() {
     85   SendSyncMessageToPage(HIDE, std::string(), std::string());
     86 }
     87 
     88 void NewTabPageSyncHandler::BuildAndSendSyncStatus() {
     89   DCHECK(!waiting_for_initial_page_load_);
     90   SigninManagerBase* signin = SigninManagerFactory::GetForProfile(
     91       Profile::FromWebUI(web_ui()));
     92 
     93   // Hide the sync status section if sync is managed or disabled entirely.
     94   if (!sync_service_ ||
     95       sync_service_->IsManaged() ||
     96       !signin ||
     97       !signin->IsSigninAllowed()) {
     98     HideSyncStatusSection();
     99     return;
    100   }
    101 
    102   // Don't show sync status if setup is not complete.
    103   if (!sync_service_->HasSyncSetupCompleted()) {
    104     return;
    105   }
    106 
    107   // Once sync has been enabled, the supported "sync statuses" for the NNTP
    108   // from the user's perspective are:
    109   //
    110   // "Sync error", when we can't authenticate or establish a connection with
    111   //               the sync server (appropriate information appended to
    112   //               message).
    113   base::string16 status_msg;
    114   base::string16 link_text;
    115 
    116   sync_ui_util::MessageType type =
    117       sync_ui_util::GetStatusLabelsForNewTabPage(sync_service_,
    118                                                  *signin,
    119                                                  &status_msg,
    120                                                  &link_text);
    121   SendSyncMessageToPage(FromSyncStatusMessageType(type),
    122                         base::UTF16ToUTF8(status_msg),
    123                         base::UTF16ToUTF8(link_text));
    124 }
    125 
    126 void NewTabPageSyncHandler::HandleSyncLinkClicked(const base::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     base::string16 user = base::UTF8ToUTF16(SigninManagerFactory::GetForProfile(
    138         Profile::FromWebUI(web_ui()))->GetAuthenticatedUsername());
    139     base::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   base::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 }
    205