Remove TOUCH_UI specific new tab page.

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

 // Copyright (c) 2011 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 <string>
 #include <vector>
 
 #include "base/auto_reset.h"
@@ skipping 75 matching lines @@
   dictionary->SetString("body", notification.body());
   if (!notification.link_url().is_empty()) {
     dictionary->SetString("linkUrl", notification.link_url().spec());
     dictionary->SetString("linkText", notification.link_text());
   }
   return dictionary;
 }
 
 // static
 bool AppLauncherHandler::IsAppExcludedFromList(const Extension* extension) {
-  // Don't include the WebStore and the Cloud Print app.
-  // The WebStore launcher gets special treatment in ntp/apps.js.
   // The Cloud Print app should never be displayed in the NTP.
-  bool ntp3 =
-      !NewTabUI::NTP4Enabled();
   if (!extension->is_app() ||
-      (ntp3 && extension->id() == extension_misc::kWebStoreAppId) ||
       (extension->id() == extension_misc::kCloudPrintAppId)) {
     return true;
   }
   return false;
 }
 
 void AppLauncherHandler::CreateAppInfo(const Extension* extension,
                                        const AppNotification* notification,
                                        ExtensionService* service,
                                        DictionaryValue* value) {
   bool enabled = service->IsExtensionEnabled(extension->id()) &&
       !service->GetTerminatedExtension(extension->id());
   bool icon_big_exists = true;
-  // Instead of setting grayscale here, we do it in apps_page.js in NTP4.
-  bool grayscale = NewTabUI::NTP4Enabled() ? false : !enabled;
+  // Instead of setting grayscale here, we do it in apps_page.js.
   GURL icon_big =
       ExtensionIconSource::GetIconURL(extension,
                                       Extension::EXTENSION_ICON_LARGE,
                                       ExtensionIconSet::MATCH_EXACTLY,
-                                      grayscale, &icon_big_exists);
+                                      false, &icon_big_exists);
   bool icon_small_exists = true;
   GURL icon_small =
       ExtensionIconSource::GetIconURL(extension,
                                       Extension::EXTENSION_ICON_BITTY,
                                       ExtensionIconSet::MATCH_BIGGER,
-                                      grayscale, &icon_small_exists);
+                                      false, &icon_small_exists);
 
   value->Clear();
 
   // The Extension class 'helpfully' wraps bidi control characters that
   // impede our ability to determine directionality.
   string16 name = UTF8ToUTF16(extension->name());
   base::i18n::UnadjustStringForLocaleDirection(&name);
   NewTabUI::SetURLTitleAndDirection(value, name, extension->GetFullLaunchURL());
 
   value->SetString("id", extension->id());
   value->SetString("description", extension->description());
   value->SetBoolean("enabled", enabled);
-  if (NewTabUI::NTP4Enabled() || enabled)
-    value->SetString("options_url", extension->options_url().spec());
+  value->SetString("options_url", extension->options_url().spec());
   value->SetBoolean("can_uninstall",
                     Extension::UserMayDisable(extension->location()));
   value->SetString("icon_big", icon_big.spec());
   value->SetBoolean("icon_big_exists", icon_big_exists);
   value->SetString("icon_small", icon_small.spec());
   value->SetBoolean("icon_small_exists", icon_small_exists);
   value->SetInteger("launch_container", extension->launch_container());
   ExtensionPrefs* prefs = service->extension_prefs();
   value->SetInteger("launch_type",
       prefs->GetLaunchType(extension->id(),
@@ skipping 74 matching lines @@
       base::Bind(&AppLauncherHandler::HandleRecordAppLaunchByURL,
                  base::Unretained(this)));
   web_ui_->RegisterMessageCallback("closeNotification",
       base::Bind(&AppLauncherHandler::HandleNotificationClose,
                  base::Unretained(this)));
 }
 
 void AppLauncherHandler::Observe(int type,
                                  const content::NotificationSource& source,
                                  const content::NotificationDetails& details) {
-  if (type == chrome::NOTIFICATION_APP_INSTALLED_TO_NTP &&
-          NewTabUI::NTP4Enabled()) {
+  if (type == chrome::NOTIFICATION_APP_INSTALLED_TO_NTP) {
     highlight_app_id_ = *content::Details<const std::string>(details).ptr();
     if (has_loaded_apps_)
       SetAppToBeHighlighted();
     return;
   }
 
   if (ignore_changes_ || !has_loaded_apps_)
     return;
 
   switch (type) {
@@ skipping 17 matching lines @@
       }
       break;
     }
 
     case chrome::NOTIFICATION_EXTENSION_LOADED: {
       const Extension* extension =
           content::Details<const Extension>(details).ptr();
       if (!extension->is_app())
         return;
 
-      if (!NewTabUI::NTP4Enabled()) {
-        HandleGetApps(NULL);
-        break;
-      }
-
       scoped_ptr<DictionaryValue> app_info(GetAppInfo(extension));
       if (app_info.get()) {
         ExtensionPrefs* prefs = extension_service_->extension_prefs();
         scoped_ptr<base::FundamentalValue> highlight(Value::CreateBooleanValue(
               prefs->IsFromBookmark(extension->id()) &&
               attempted_bookmark_app_install_));
         attempted_bookmark_app_install_ = false;
         web_ui_->CallJavascriptFunction("ntp4.appAdded", *app_info, *highlight);
       }
 
       break;
     }
     case chrome::NOTIFICATION_EXTENSION_UNLOADED: {
       const Extension* extension =
           content::Details<UnloadedExtensionInfo>(details)->extension;
       if (!extension->is_app())
         return;
 
-      if (!NewTabUI::NTP4Enabled()) {
-        HandleGetApps(NULL);
-        break;
-      }
-
       scoped_ptr<DictionaryValue> app_info(GetAppInfo(extension));
       scoped_ptr<base::FundamentalValue> uninstall_value(
           Value::CreateBooleanValue(
               content::Details<UnloadedExtensionInfo>(details)->reason ==
               extension_misc::UNLOAD_REASON_UNINSTALL));
       if (app_info.get()) {
         web_ui_->CallJavascriptFunction(
             "ntp4.appRemoved", *app_info, *uninstall_value);
       }
       break;
@@ skipping 86 matching lines @@
   // Making shortcut does not make sense on ChromeOS because it does not have
   // a desktop.
   dictionary->SetBoolean("disableCreateAppShortcut", true);
 #endif
 
   dictionary->SetBoolean(
       "showLauncher",
       extension_service_->apps_promo()->ShouldShowAppLauncher(
           extension_service_->GetAppIds()));
 
-  if (NewTabUI::NTP4Enabled()) {
-    PrefService* prefs = Profile::FromWebUI(web_ui_)->GetPrefs();
-    const ListValue* app_page_names = prefs->GetList(prefs::kNTPAppPageNames);
-    if (!app_page_names || !app_page_names->GetSize()) {
-      ListPrefUpdate update(prefs, prefs::kNTPAppPageNames);
-      ListValue* list = update.Get();
-      list->Set(0, Value::CreateStringValue(
-          l10n_util::GetStringUTF16(IDS_APP_DEFAULT_PAGE_NAME)));
-      dictionary->Set("appPageNames",
-                      static_cast<ListValue*>(list->DeepCopy()));
-    } else {
-      dictionary->Set("appPageNames",
-                      static_cast<ListValue*>(app_page_names->DeepCopy()));
-    }
+  PrefService* prefs = Profile::FromWebUI(web_ui_)->GetPrefs();
+  const ListValue* app_page_names = prefs->GetList(prefs::kNTPAppPageNames);
+  if (!app_page_names || !app_page_names->GetSize()) {
+    ListPrefUpdate update(prefs, prefs::kNTPAppPageNames);
+    ListValue* list = update.Get();
+    list->Set(0, Value::CreateStringValue(
+        l10n_util::GetStringUTF16(IDS_APP_DEFAULT_PAGE_NAME)));
+    dictionary->Set("appPageNames",
+                    static_cast<ListValue*>(list->DeepCopy()));
+  } else {
+    dictionary->Set("appPageNames",
+                    static_cast<ListValue*>(app_page_names->DeepCopy()));
   }
 }
 
 DictionaryValue* AppLauncherHandler::GetAppInfo(const Extension* extension) {
   AppNotificationManager* notification_manager =
       extension_service_->app_notification_manager();
   DictionaryValue* app_info = new DictionaryValue();
   // CreateAppInfo can change the extension prefs.
   AutoReset<bool> auto_reset(&ignore_changes_, true);
   CreateAppInfo(extension,
@@ skipping 115 matching lines @@
   // If the user pressed special keys when clicking, override the saved
   // preference for launch container.
   bool middle_button = (button == 1.0);
   WindowOpenDisposition disposition =
         disposition_utils::DispositionFromClick(middle_button, alt_key,
                                                 ctrl_key, meta_key, shift_key);
 
   if (extension_id != extension_misc::kWebStoreAppId) {
     RecordAppLaunchByID(launch_bucket);
     extension_service_->apps_promo()->ExpireDefaultApps();
-  } else if (NewTabUI::NTP4Enabled()) {
+  } else {
     RecordWebStoreLaunch(url.find("chrome-ntp-promo") != std::string::npos);
   }
 
   if (disposition == NEW_FOREGROUND_TAB || disposition == NEW_BACKGROUND_TAB) {
     // TODO(jamescook): Proper support for background tabs.
     Browser::OpenApplication(
         profile, extension, extension_misc::LAUNCH_TAB, GURL(url), disposition);
   } else if (disposition == NEW_WINDOW) {
     // Force a new window open.
     Browser::OpenApplication(
@@ skipping 28 matching lines @@
   double launch_type;
   CHECK(args->GetString(0, &extension_id));
   CHECK(args->GetDouble(1, &launch_type));
 
   const Extension* extension =
       extension_service_->GetExtensionById(extension_id, true);
   if (!extension)
     return;
 
   // Don't update the page; it already knows about the launch type change.
-  scoped_ptr<AutoReset<bool> > auto_reset;
-  if (NewTabUI::NTP4Enabled())
-    auto_reset.reset(new AutoReset<bool>(&ignore_changes_, true));
+  AutoReset<bool> auto_reset(&ignore_changes_, true);
 
   extension_service_->extension_prefs()->SetLaunchType(
       extension_id,
       static_cast<ExtensionPrefs::LaunchType>(
           static_cast<int>(launch_type)));
 }
 
 void AppLauncherHandler::HandleUninstallApp(const ListValue* args) {
   std::string extension_id;
   CHECK(args->GetString(0, &extension_id));
 
   const Extension* extension = extension_service_->GetExtensionById(
       extension_id, true);
   if (!extension)
     return;
 
   if (!Extension::UserMayDisable(extension->location())) {
     LOG(ERROR) << "Attempt to uninstall an extension that is non-usermanagable "
                << "was made. Extension id : " << extension->id();
     return;
   }
   if (!extension_id_prompting_.empty())
     return;  // Only one prompt at a time.
 
   extension_id_prompting_ = extension_id;
 
   bool dont_confirm = false;
   if (args->GetBoolean(1, &dont_confirm) && dont_confirm) {
-    scoped_ptr<AutoReset<bool> > auto_reset;
-    if (NewTabUI::NTP4Enabled())
-      auto_reset.reset(new AutoReset<bool>(&ignore_changes_, true));
+    AutoReset<bool> auto_reset(&ignore_changes_, true);
     ExtensionUninstallAccepted();
   } else {
     GetExtensionUninstallDialog()->ConfirmUninstall(extension);
   }
 }
 
 void AppLauncherHandler::HandleHideAppsPromo(const ListValue* args) {
   // If the user has intentionally hidden the promotion, we'll uninstall all the
   // default apps (we know the user hasn't installed any apps on their own at
   // this point, or the promotion wouldn't have been shown).
   // TODO(estade): this isn't used right now as we sort out the future of the
   // apps promo on ntp4.
-  if (NewTabUI::NTP4Enabled()) {
-    UninstallDefaultApps();
-    extension_service_->apps_promo()->HidePromo();
-  } else {
-    // TODO(estade): remove all this. NTP3 uninstalled all the default apps then
-    // refreshed the entire NTP, we don't have to jump through these hoops for
-    // NTP4 because each app uninstall is handled separately without reloading
-    // the entire page.
-    ignore_changes_ = true;
-    UninstallDefaultApps();
-    extension_service_->apps_promo()->HidePromo();
-    ignore_changes_ = false;
-    HandleGetApps(NULL);
-  }
+  UninstallDefaultApps();
+  extension_service_->apps_promo()->HidePromo();
 }
 
 void AppLauncherHandler::HandleCreateAppShortcut(const ListValue* args) {
   std::string extension_id;
   CHECK(args->GetString(0, &extension_id));
 
   const Extension* extension =
       extension_service_->GetExtensionById(extension_id, true);
   if (!extension)
     return;
@@ skipping 15 matching lines @@
   CHECK(args->GetList(1, &app_order));
 
   std::vector<std::string> extension_ids;
   for (size_t i = 0; i < app_order->GetSize(); ++i) {
     std::string value;
     if (app_order->GetString(i, &value))
       extension_ids.push_back(value);
   }
 
   // Don't update the page; it already knows the apps have been reordered.
-  scoped_ptr<AutoReset<bool> > auto_reset;
-  if (NewTabUI::NTP4Enabled())
-    auto_reset.reset(new AutoReset<bool>(&ignore_changes_, true));
-
+  AutoReset<bool> auto_reset(&ignore_changes_, true);
   extension_service_->extension_prefs()->SetAppDraggedByUser(dragged_app_id);
   extension_service_->extension_prefs()->SetAppLauncherOrder(extension_ids);
 }
 
 void AppLauncherHandler::HandleSetPageIndex(const ListValue* args) {
   std::string extension_id;
   double page_index;
   CHECK(args->GetString(0, &extension_id));
   CHECK(args->GetDouble(1, &page_index));
 
   // Don't update the page; it already knows the apps have been reordered.
-  scoped_ptr<AutoReset<bool> > auto_reset;
-  if (NewTabUI::NTP4Enabled())
-    auto_reset.reset(new AutoReset<bool>(&ignore_changes_, true));
-
+  AutoReset<bool> auto_reset(&ignore_changes_, true);
   extension_service_->extension_prefs()->SetPageIndex(extension_id,
       static_cast<int>(page_index));
 }
 
 void AppLauncherHandler::HandlePromoSeen(const ListValue* args) {
   UMA_HISTOGRAM_ENUMERATION(extension_misc::kAppsPromoHistogram,
                             extension_misc::PROMO_SEEN,
                             extension_misc::PROMO_BUCKET_BOUNDARY);
 }
 
@@ skipping 263 matching lines @@
 
 void AppLauncherHandler::UninstallDefaultApps() {
   AppsPromo* apps_promo = extension_service_->apps_promo();
   const ExtensionIdSet& app_ids = apps_promo->old_default_apps();
   for (ExtensionIdSet::const_iterator iter = app_ids.begin();
        iter != app_ids.end(); ++iter) {
     if (extension_service_->GetExtensionById(*iter, true))
       extension_service_->UninstallExtension(*iter, false, NULL);
   }
 }