NTP4/apps page: fix page stickiness

chrome/browser/ui/webui/ntp/app_launcher_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/app_launcher_handler.h"
 
 #include <stddef.h>
 
 #include <vector>
 
@@ skipping 30 matching lines @@
 #include "chrome/browser/ui/webui/ntp/new_tab_ui.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_metrics.h"
 #include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/common/web_application_info.h"
 #include "chrome/grit/generated_resources.h"
 #include "components/favicon_base/favicon_types.h"
+#include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_service.h"
 #include "components/prefs/scoped_user_pref_update.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/common/favicon_url.h"
 #include "extensions/browser/app_sorting.h"
 #include "extensions/browser/extension_prefs.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/management_policy.h"
@@ skipping 11 matching lines @@
 using extensions::AppSorting;
 using extensions::CrxInstaller;
 using extensions::Extension;
 using extensions::ExtensionPrefs;
 using extensions::ExtensionRegistry;
 using extensions::ExtensionSet;
 using extensions::ExtensionSystem;
 
 namespace {
 
+// The purpose of this enum is to track which page on the NTP is showing.
+// The lower 10 bits of kNtpShownPage are used for the index within the page
+// group, and the rest of the bits are used for the page group ID (defined
+// here).
+static const int kPageIdOffset = 10;
+enum {
+  INDEX_MASK = (1 << kPageIdOffset) - 1,
+  APPS_PAGE_ID = 2 << kPageIdOffset,
+};
+
 void RecordAppLauncherPromoHistogram(
       apps::AppLauncherPromoHistogramValues value) {
   DCHECK_LT(value, apps::APP_LAUNCHER_PROMO_MAX);
   UMA_HISTOGRAM_ENUMERATION(
       "Apps.AppLauncherPromo", value, apps::APP_LAUNCHER_PROMO_MAX);
 }
 
-// This is used to avoid a DCHECK due to an unhandled WebUI callback. The
-// JavaScript used to switch between pages sends "pageSelected" which is used
-// in the context of the NTP for recording metrics we don't need here.
-void NoOpCallback(const base::ListValue* args) {}
-
 }  // namespace
 
 AppLauncherHandler::AppInstallInfo::AppInstallInfo() {}
 
 AppLauncherHandler::AppInstallInfo::~AppInstallInfo() {}
 
 AppLauncherHandler::AppLauncherHandler(ExtensionService* extension_service)
     : extension_service_(extension_service),
       ignore_changes_(false),
       attempted_bookmark_app_install_(false),
@@ skipping 95 matching lines @@
     // ordinal). The webstore's app launch ordinal is always set to the first
     // position.
     app_launch_ordinal = extension->id() == extensions::kWebStoreAppId ?
         sorting->CreateFirstAppLaunchOrdinal(page_ordinal) :
         sorting->CreateNextAppLaunchOrdinal(page_ordinal);
     sorting->SetAppLaunchOrdinal(extension->id(), app_launch_ordinal);
   }
   value->SetString("app_launch_ordinal", app_launch_ordinal.ToInternalValue());
 }
 
+// static
+void AppLauncherHandler::GetLocalizedValues(Profile* profile,
+                                            base::DictionaryValue* values) {
+  PrefService* prefs = profile->GetPrefs();
+  int shown_page = prefs->GetInteger(prefs::kNtpShownPage);
+  values->SetInteger("shown_page_index", shown_page & INDEX_MASK);
+}
+
+// static
+void AppLauncherHandler::RegisterProfilePrefs(
+    user_prefs::PrefRegistrySyncable* registry) {
+  // TODO(estade): should be syncable.

[Evan Stade, 2016/03/03 19:59:53]

this is so meh-worthy I wouldn't mind if you removed the todo

[Dan Beam, 2016/03/03 21:09:41]

Done.

+  registry->RegisterIntegerPref(prefs::kNtpShownPage, APPS_PAGE_ID);
+}
+
 void AppLauncherHandler::RegisterMessages() {
   registrar_.Add(this, chrome::NOTIFICATION_APP_INSTALLED_TO_NTP,
       content::Source<WebContents>(web_ui()->GetWebContents()));
 
   // Some tests don't have a local state.
 #if defined(ENABLE_APP_LIST)
   if (g_browser_process->local_state()) {
     local_state_pref_change_registrar_.Init(g_browser_process->local_state());
     local_state_pref_change_registrar_.Add(
         prefs::kShowAppLauncherPromo,
@@ skipping 25 matching lines @@
   web_ui()->RegisterMessageCallback("setPageIndex",
       base::Bind(&AppLauncherHandler::HandleSetPageIndex,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("saveAppPageName",
       base::Bind(&AppLauncherHandler::HandleSaveAppPageName,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("generateAppForLink",
       base::Bind(&AppLauncherHandler::HandleGenerateAppForLink,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("stopShowingAppLauncherPromo",
-      base::Bind(&AppLauncherHandler::StopShowingAppLauncherPromo,
+      base::Bind(&AppLauncherHandler::HandleStopShowingAppLauncherPromo,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("onLearnMore",
-      base::Bind(&AppLauncherHandler::OnLearnMore,
+      base::Bind(&AppLauncherHandler::HandleOnLearnMore,
                  base::Unretained(this)));
-  web_ui()->RegisterMessageCallback("pageSelected", base::Bind(&NoOpCallback));
+  web_ui()->RegisterMessageCallback("pageSelected",
+      base::Bind(&AppLauncherHandler::HandlePageSelected,
+                 base::Unretained(this)));
 }
 
 void AppLauncherHandler::Observe(int type,
                                  const content::NotificationSource& source,
                                  const content::NotificationDetails& details) {
   if (type == chrome::NOTIFICATION_APP_INSTALLED_TO_NTP) {
     highlight_app_id_ = *content::Details<const std::string>(details).ptr();
     if (has_loaded_apps_)
       SetAppToBeHighlighted();
     return;
@@ skipping 433 matching lines @@
   install_info->page_ordinal = page_ordinal;
 
   favicon_service->GetFaviconImageForPageURL(
       launch_url,
       base::Bind(&AppLauncherHandler::OnFaviconForApp,
                  base::Unretained(this),
                  base::Passed(&install_info)),
       &cancelable_task_tracker_);
 }
 
-void AppLauncherHandler::StopShowingAppLauncherPromo(
+void AppLauncherHandler::HandleStopShowingAppLauncherPromo(
     const base::ListValue* args) {
 #if defined(ENABLE_APP_LIST)
   g_browser_process->local_state()->SetBoolean(
       prefs::kShowAppLauncherPromo, false);
   RecordAppLauncherPromoHistogram(apps::APP_LAUNCHER_PROMO_DISMISSED);
 #endif
 }
 
-void AppLauncherHandler::OnLearnMore(const base::ListValue* args) {
+void AppLauncherHandler::HandleOnLearnMore(const base::ListValue* args) {
   RecordAppLauncherPromoHistogram(apps::APP_LAUNCHER_PROMO_LEARN_MORE);
 }
 
+void AppLauncherHandler::HandlePageSelected(const base::ListValue* args) {
+  double index_double;
+  CHECK(args->GetDouble(0, &index_double));
+  int index = static_cast<int>(index_double);
+
+  PrefService* prefs = Profile::FromWebUI(web_ui())->GetPrefs();
+  prefs->SetInteger(prefs::kNtpShownPage, APPS_PAGE_ID | index);
+}
+
 void AppLauncherHandler::OnFaviconForApp(
     scoped_ptr<AppInstallInfo> install_info,
     const favicon_base::FaviconImageResult& image_result) {
   scoped_ptr<WebApplicationInfo> web_app(new WebApplicationInfo());
   web_app->title = install_info->title;
   web_app->app_url = install_info->app_url;
 
   if (!image_result.image.IsEmpty()) {
     WebApplicationInfo::IconInfo icon;
     icon.data = image_result.image.AsBitmap();
@@ skipping 112 matching lines @@
       base::FundamentalValue(!extension_id_prompting_.empty()));
 }
 
 bool AppLauncherHandler::ShouldShow(const Extension* extension) const {
   if (ignore_changes_ || !has_loaded_apps_ || !extension->is_app())
     return false;
 
   Profile* profile = Profile::FromWebUI(web_ui());
   return extensions::ui_util::ShouldDisplayInNewTabPage(extension, profile);
 }