Add a SigninAllowed policy.

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

 // Copyright (c) 2012 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/ntp/new_tab_page_sync_handler.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 28 matching lines @@
 // configurable.
 static const char kSyncDefaultViewOnlineUrl[] = "http://docs.google.com";
 
 NewTabPageSyncHandler::NewTabPageSyncHandler() : sync_service_(NULL),
   waiting_for_initial_page_load_(true) {
 }
 
 NewTabPageSyncHandler::~NewTabPageSyncHandler() {
   if (sync_service_)
     sync_service_->RemoveObserver(this);
+  profile_pref_registrar_.RemoveAll();

[Dan Beam, 2013/02/25 17:35:08]

probably isn't necessary.
https://code.google.com/p/chromium/codesearch#chromium/src/base/prefs/public/...

 }
 
 // static
 NewTabPageSyncHandler::MessageType
     NewTabPageSyncHandler::FromSyncStatusMessageType(
         sync_ui_util::MessageType type) {
   switch (type) {
     case sync_ui_util::SYNC_ERROR:
       return SYNC_ERROR;
     case sync_ui_util::SYNC_PROMO:
       return SYNC_PROMO;
     case sync_ui_util::PRE_SYNCED:
     case sync_ui_util::SYNCED:
     default:
       return HIDE;
   }
 }
 
 void NewTabPageSyncHandler::RegisterMessages() {
   sync_service_ = ProfileSyncServiceFactory::GetInstance()->GetForProfile(
       Profile::FromWebUI(web_ui()));
   if (sync_service_)
     sync_service_->AddObserver(this);
+  profile_pref_registrar_.Init(Profile::FromWebUI(web_ui())->GetPrefs());
+  profile_pref_registrar_.Add(
+      prefs::kSigninAllowed,
+      base::Bind(&NewTabPageSyncHandler::OnSigninAllowedPrefChange,
+                 base::Unretained(this)));
 
   web_ui()->RegisterMessageCallback("GetSyncMessage",
       base::Bind(&NewTabPageSyncHandler::HandleGetSyncMessage,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("SyncLinkClicked",
       base::Bind(&NewTabPageSyncHandler::HandleSyncLinkClicked,
                  base::Unretained(this)));
 }
 
 void NewTabPageSyncHandler::HandleGetSyncMessage(const ListValue* args) {
   waiting_for_initial_page_load_ = false;
   BuildAndSendSyncStatus();
 }
 
 void NewTabPageSyncHandler::HideSyncStatusSection() {
   SendSyncMessageToPage(HIDE, std::string(), std::string());
 }
 
 void NewTabPageSyncHandler::BuildAndSendSyncStatus() {
   DCHECK(!waiting_for_initial_page_load_);
+  SigninManager* signin = SigninManagerFactory::GetForProfile(
+      Profile::FromWebUI(web_ui()));
 
   // Hide the sync status section if sync is managed or disabled entirely.
-  if (!sync_service_ || sync_service_->IsManaged()) {
+  if (!sync_service_ ||
+      sync_service_->IsManaged() ||
+      !signin ||
+      !signin->IsSigninAllowed()) {
     HideSyncStatusSection();
     return;
   }
 
   // Don't show sync status if setup is not complete.
   if (!sync_service_->HasSyncSetupCompleted()) {
     return;
   }
 
   // Once sync has been enabled, the supported "sync statuses" for the NNTP
   // from the user's perspective are:
   //
   // "Sync error", when we can't authenticate or establish a connection with
   //               the sync server (appropriate information appended to
   //               message).
   string16 status_msg;
   string16 link_text;
-  SigninManager* signin = SigninManagerFactory::GetForProfile(
-      Profile::FromWebUI(web_ui()));
 
   sync_ui_util::MessageType type =
       sync_ui_util::GetStatusLabelsForNewTabPage(sync_service_,
                                                  *signin,
                                                  &status_msg,
                                                  &link_text);
   SendSyncMessageToPage(FromSyncStatusMessageType(type),
                         UTF16ToUTF8(status_msg), UTF16ToUTF8(link_text));
 }
 
@@ skipping 20 matching lines @@
   }
 }
 
 void NewTabPageSyncHandler::OnStateChanged() {
   // Don't do anything if the page has not yet loaded.
   if (waiting_for_initial_page_load_)
     return;
   BuildAndSendSyncStatus();
 }
 
+void NewTabPageSyncHandler::OnSigninAllowedPrefChange() {
+  // Don't do anything if the page has not yet loaded.
+  if (waiting_for_initial_page_load_)
+    return;
+  BuildAndSendSyncStatus();
+}
+
 void NewTabPageSyncHandler::SendSyncMessageToPage(
     MessageType type, std::string msg,
     std::string linktext) {
   DictionaryValue value;
   std::string user;
   std::string title;
   std::string linkurl;
 
   // If there is nothing to show, we should hide the sync section altogether.
   if (type == HIDE || (msg.empty() && linktext.empty())) {
@@ skipping 22 matching lines @@
       if (linkurl.empty()) {
         value.SetBoolean("linkurlisset", false);
       } else {
         value.SetBoolean("linkurlisset", true);
         value.SetString("linkurl", linkurl);
       }
     }
   }
   web_ui()->CallJavascriptFunction("ntp.syncMessageChanged", value);
 }