Renames LauncherID, LauncherItem and LauncherItems...

ash/shell/app_list.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 <string>
 
 #include "ash/session_state_delegate.h"
 #include "ash/shell.h"
 #include "ash/shell/example_factory.h"
 #include "ash/shell/toplevel_window.h"
@@ skipping 17 matching lines @@
 #include "ui/gfx/font_list.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/views/examples/examples_window_with_content.h"
 
 namespace ash {
 namespace shell {
 
 namespace {
 
-// WindowTypeLauncherItem is an app item of app list. It carries a window
+// WindowTypeShelfItem is an app item of app list. It carries a window
 // launch type and launches corresponding example window when activated.
-class WindowTypeLauncherItem : public app_list::AppListItem {
+class WindowTypeShelfItem : public app_list::AppListItem {
  public:
   enum Type {
     TOPLEVEL_WINDOW = 0,
     NON_RESIZABLE_WINDOW,
     LOCK_SCREEN,
     WIDGETS_WINDOW,
     EXAMPLES_WINDOW,
     LAST_TYPE,
   };
 
-  explicit WindowTypeLauncherItem(const std::string& id, Type type)
+  explicit WindowTypeShelfItem(const std::string& id, Type type)
       : app_list::AppListItem(id),
         type_(type) {
     std::string title(GetTitle(type));
     SetIcon(GetIcon(type), false);
     SetTitleAndFullName(title, title);
   }
 
   static gfx::ImageSkia GetIcon(Type type) {
     static const SkColor kColors[] = {
         SK_ColorRED,
@@ skipping 76 matching lines @@
   }
 
   // AppListItem
   virtual void Activate(int event_flags) OVERRIDE {
     ActivateItem(type_, event_flags);
   }
 
  private:
   Type type_;
 
-  DISALLOW_COPY_AND_ASSIGN(WindowTypeLauncherItem);
+  DISALLOW_COPY_AND_ASSIGN(WindowTypeShelfItem);
 };
 
 // ExampleSearchResult is an app list search result. It provides what icon to
 // show, what should title and details text look like. It also carries the
 // matching window launch type so that AppListViewDelegate knows how to open
 // it.
 class ExampleSearchResult : public app_list::SearchResult {
  public:
-  ExampleSearchResult(WindowTypeLauncherItem::Type type,
+  ExampleSearchResult(WindowTypeShelfItem::Type type,
                       const base::string16& query)
       : type_(type) {
-    SetIcon(WindowTypeLauncherItem::GetIcon(type_));
+    SetIcon(WindowTypeShelfItem::GetIcon(type_));
 
     base::string16 title =
-        base::UTF8ToUTF16(WindowTypeLauncherItem::GetTitle(type_));
+        base::UTF8ToUTF16(WindowTypeShelfItem::GetTitle(type_));
     set_title(title);
 
     Tags title_tags;
     const size_t match_len = query.length();
 
     // Highlight matching parts in title with bold.
     // Note the following is not a proper way to handle i18n string.
     title = base::i18n::ToLower(title);
     size_t match_start = title.find(query);
     while (match_start != base::string16::npos) {
       title_tags.push_back(Tag(Tag::MATCH,
                                match_start,
                                match_start + match_len));
       match_start = title.find(query, match_start + match_len);
     }
     set_title_tags(title_tags);
 
     base::string16 details =
-        base::UTF8ToUTF16(WindowTypeLauncherItem::GetDetails(type_));
+        base::UTF8ToUTF16(WindowTypeShelfItem::GetDetails(type_));
     set_details(details);
     Tags details_tags;
     details_tags.push_back(Tag(Tag::DIM, 0, details.length()));
     set_details_tags(details_tags);
   }
 
-  WindowTypeLauncherItem::Type type() const { return type_; }
+  WindowTypeShelfItem::Type type() const { return type_; }
 
  private:
-  WindowTypeLauncherItem::Type type_;
+  WindowTypeShelfItem::Type type_;
 
   DISALLOW_COPY_AND_ASSIGN(ExampleSearchResult);
 };
 
 class ExampleAppListViewDelegate : public app_list::AppListViewDelegate {
  public:
   ExampleAppListViewDelegate()
       : model_(new app_list::AppListModel) {
     PopulateApps();
     DecorateSearchBox(model_->search_box());
   }
 
  private:
   void PopulateApps() {
-    for (int i = 0;
-         i < static_cast<int>(WindowTypeLauncherItem::LAST_TYPE);
-         ++i) {
-      WindowTypeLauncherItem::Type type =
-          static_cast<WindowTypeLauncherItem::Type>(i);
+    for (int i = 0; i < static_cast<int>(WindowTypeShelfItem::LAST_TYPE); ++i) {
+      WindowTypeShelfItem::Type type =
+          static_cast<WindowTypeShelfItem::Type>(i);
       std::string id = base::StringPrintf("%d", i);
-      model_->AddItem(new WindowTypeLauncherItem(id, type));
+      model_->AddItem(new WindowTypeShelfItem(id, type));
     }
   }
 
   gfx::ImageSkia CreateSearchBoxIcon() {
     const base::string16 icon_text = base::ASCIIToUTF16("ash");
     const gfx::Size icon_size(32, 32);
 
     gfx::Canvas canvas(icon_size, 1.0f, false /* is_opaque */);
     canvas.DrawStringRectWithFlags(
         icon_text,
@@ skipping 36 matching lines @@
   virtual void GetShortcutPathForApp(
       const std::string& app_id,
       const base::Callback<void(const base::FilePath&)>& callback) OVERRIDE {
     callback.Run(base::FilePath());
   }
 
   virtual void OpenSearchResult(app_list::SearchResult* result,
                                 int event_flags) OVERRIDE {
     const ExampleSearchResult* example_result =
         static_cast<const ExampleSearchResult*>(result);
-    WindowTypeLauncherItem::ActivateItem(example_result->type(), event_flags);
+    WindowTypeShelfItem::ActivateItem(example_result->type(), event_flags);
   }
 
   virtual void InvokeSearchResultAction(app_list::SearchResult* result,
                                         int action_index,
                                         int event_flags) OVERRIDE {
     NOTIMPLEMENTED();
   }
 
   virtual base::TimeDelta GetAutoLaunchTimeout() OVERRIDE {
     return base::TimeDelta();
   }
 
   virtual void AutoLaunchCanceled() OVERRIDE {
   }
 
   virtual void StartSearch() OVERRIDE {
     base::string16 query;
     TrimWhitespace(model_->search_box()->text(), TRIM_ALL, &query);
     query = base::i18n::ToLower(query);
 
     model_->results()->DeleteAll();
     if (query.empty())
       return;
 
-    for (int i = 0;
-         i < static_cast<int>(WindowTypeLauncherItem::LAST_TYPE);
-         ++i) {
-      WindowTypeLauncherItem::Type type =
-          static_cast<WindowTypeLauncherItem::Type>(i);
+    for (int i = 0; i < static_cast<int>(WindowTypeShelfItem::LAST_TYPE); ++i) {
+      WindowTypeShelfItem::Type type =
+          static_cast<WindowTypeShelfItem::Type>(i);
 
       base::string16 title =
-          base::UTF8ToUTF16(WindowTypeLauncherItem::GetTitle(type));
+          base::UTF8ToUTF16(WindowTypeShelfItem::GetTitle(type));
       if (base::i18n::StringSearchIgnoringCaseAndAccents(
               query, title, NULL, NULL)) {
         model_->results()->Add(new ExampleSearchResult(type, query));
       }
     }
   }
 
   virtual void StopSearch() OVERRIDE {
     // Nothing needs to be done.
   }
@@ skipping 53 matching lines @@
 };
 
 }  // namespace
 
 app_list::AppListViewDelegate* CreateAppListViewDelegate() {
   return new ExampleAppListViewDelegate;
 }
 
 }  // namespace shell
 }  // namespace ash