Facelifts to sync UI

chrome/browser/dom_ui/new_tab_page_sync_handler.cc

 // Copyright (c) 2006-2008 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.
 
 #ifdef CHROME_PERSONALIZATION
 
 #include "chrome/browser/dom_ui/new_tab_page_sync_handler.h"
 
 #include "app/l10n_util.h"
 #include "base/json_writer.h"
@@ skipping 62 matching lines @@
 
 NewTabPageSyncHandler::NewTabPageSyncHandler() : sync_service_(NULL),
   waiting_for_initial_page_load_(true) {
 }
 
 NewTabPageSyncHandler::~NewTabPageSyncHandler() {
   if (sync_service_)
     sync_service_->RemoveObserver(this);
 }
 
+// static
+NewTabPageSyncHandler::MessageType
+    NewTabPageSyncHandler::FromSyncStatusMessageType(
+        SyncStatusUIHelper::MessageType type) {
+  switch (type) {
+    case SyncStatusUIHelper::SYNC_ERROR:
+      return SYNC_ERROR;
+    case SyncStatusUIHelper::PRE_SYNCED:
+    case SyncStatusUIHelper::SYNCED:
+    default:
+      return HIDE;
+  }
+}
+
 DOMMessageHandler* NewTabPageSyncHandler::Attach(DOMUI* dom_ui) {
   sync_service_ = dom_ui->GetProfile()->GetProfileSyncService();
   DCHECK(sync_service_);  // This shouldn't get called by an incognito NTP.
   sync_service_->AddObserver(this);
   return DOMMessageHandler::Attach(dom_ui);
 }
 
 void NewTabPageSyncHandler::RegisterMessages() {
   dom_ui_->RegisterMessageCallback("GetSyncMessage",
       NewCallback(this, &NewTabPageSyncHandler::HandleGetSyncMessage));
   dom_ui_->RegisterMessageCallback("SyncLinkClicked",
       NewCallback(this, &NewTabPageSyncHandler::HandleSyncLinkClicked));
 }
 
 void NewTabPageSyncHandler::HandleGetSyncMessage(const Value* value) {
   waiting_for_initial_page_load_ = false;
   BuildAndSendSyncStatus();
 }
 
 void NewTabPageSyncHandler::HideSyncStatusSection() {
-  SendSyncMessageToPage(SyncStatusUIHelper::PRE_SYNCED, std::string(),
-                        std::string());
+  SendSyncMessageToPage(HIDE, std::string(), std::string());
 }
 
 void NewTabPageSyncHandler::BuildAndSendSyncStatus() {
   DCHECK(!waiting_for_initial_page_load_);
 
   // Hide the sync status section if sync is disabled entirely.
   if (!sync_service_) {
     HideSyncStatusSection();
     return;
   }
 
   // We show the sync promotion if sync has not been enabled and the user is
   // logged in to Google Accounts. If the user is not signed in to GA, we
   // should hide the sync status section entirely.
-  if (!sync_service_->HasSyncSetupCompleted() &&
-      !sync_service_->SetupInProgress()) {
-    if (IsGoogleGAIACookieInstalled()) {
-      SendSyncMessageToPage(SyncStatusUIHelper::PRE_SYNCED,
+  if (!sync_service_->HasSyncSetupCompleted()) {
+    if(!sync_service_->SetupInProgress() && IsGoogleGAIACookieInstalled()) {
+      SendSyncMessageToPage(PROMOTION,
           WideToUTF8(l10n_util::GetString(IDS_SYNC_NTP_PROMOTION_MESSAGE)),
           WideToUTF8(l10n_util::GetString(IDS_SYNC_NTP_START_NOW_LINK_LABEL)));
-    } else {
-      HideSyncStatusSection();
     }
     return;
   }
 
   // Once sync has been enabled, the supported "sync statuses" for the NNTP
   // from the user's perspective are:
   //
-  // "Synced to foo@gmail.com", when we are successfully authenticated and
-  //                            connected to a sync server.
   // "Sync error", when we can't authenticate or establish a connection with
   //               the sync server (appropriate information appended to
   //               message).
-  // "Authenticating", when credentials are in flight.
-  SyncStatusUIHelper::MessageType type(SyncStatusUIHelper::PRE_SYNCED);
   std::wstring status_msg;
   std::wstring link_text;
-  type = SyncStatusUIHelper::GetLabels(sync_service_, &status_msg, &link_text);
-  SendSyncMessageToPage(type, WideToUTF8(status_msg), WideToUTF8(link_text));
+  SyncStatusUIHelper::MessageType type =
+      SyncStatusUIHelper::GetLabels(sync_service_, &status_msg, &link_text);
+  SendSyncMessageToPage(FromSyncStatusMessageType(type),
+                        WideToUTF8(status_msg), WideToUTF8(link_text));
 }
 
 void NewTabPageSyncHandler::HandleSyncLinkClicked(const Value* value) {
   DCHECK(!waiting_for_initial_page_load_);
   DCHECK(sync_service_);
   if (sync_service_->HasSyncSetupCompleted()) {
     // User clicked the 'Login again' link to re-authenticate.
     sync_service_->ShowLoginDialog();
   } else {
     // User clicked the 'Start now' link to begin syncing.
     ProfileSyncService::SyncEvent(ProfileSyncService::START_FROM_NTP);
     sync_service_->EnableForUser();
   }
 }
 
 void NewTabPageSyncHandler::OnStateChanged() {
   // Don't do anything if the page has not yet loaded.
   if (waiting_for_initial_page_load_)
     return;
   BuildAndSendSyncStatus();
 }
 
 void NewTabPageSyncHandler::SendSyncMessageToPage(
-    SyncStatusUIHelper::MessageType type, std::string msg,
+    MessageType type, std::string msg,
     std::string linktext) {
   DictionaryValue value;
   std::string msgtype;
   std::wstring user;
   std::string title =
       WideToUTF8(l10n_util::GetString(IDS_SYNC_NTP_SYNC_SECTION_TITLE));
   std::string linkurl;
   switch (type) {
-    case SyncStatusUIHelper::PRE_SYNCED:
+    case HIDE:
+    case PROMOTION:
       msgtype = "presynced";
       break;
-    case SyncStatusUIHelper::SYNCED:
-      msgtype = "synced";
-      linktext =
-          WideToUTF8(l10n_util::GetString(IDS_SYNC_NTP_VIEW_ONLINE_LINK));
-      linkurl = kSyncDefaultViewOnlineUrl;
-      user = UTF16ToWide(sync_service_->GetAuthenticatedUsername());
-      msg = WideToUTF8(l10n_util::GetStringF(IDS_SYNC_NTP_SYNCED_TO, user));
-      break;
-    case SyncStatusUIHelper::SYNC_ERROR:
+    case SYNC_ERROR:
       title =
           WideToUTF8(
               l10n_util::GetString(IDS_SYNC_NTP_SYNC_SECTION_ERROR_TITLE));
       msgtype = "error";
       break;
+    default:
+      NOTREACHED();
+      break;
   }
 
   // If there is no message to show, we should hide the sync section
   // altogether.
-  if (msg.empty()) {
+  if (type == HIDE || msg.empty()) {
     value.SetBoolean(L"syncsectionisvisible", false);
   } else {
     value.SetBoolean(L"syncsectionisvisible", true);
     value.SetString(L"msg", msg);
     value.SetString(L"title", title);
     value.SetString(L"msgtype", msgtype);
     if (linktext.empty()) {
       value.SetBoolean(L"linkisvisible", false);
     } else {
       value.SetBoolean(L"linkisvisible", true);
       value.SetString(L"linktext", linktext);
 
       // The only time we set the URL is when the user is synced and we need to
       // show a link to a web interface (e.g. http://docs.google.com). When we
       // set that URL, HandleSyncLinkClicked won't be called when the user
       // clicks on the link.
       if (linkurl.empty()) {
         value.SetBoolean(L"linkurlisset", false);
       } else {
         value.SetBoolean(L"linkurlisset", true);
         value.SetString(L"linkurl", linkurl);
       }
     }
   }
   dom_ui_->CallJavascriptFunction(L"syncMessageChanged", value);
 }
 
 #endif  // CHROME_PERSONALIZATION