Standardize usage of virtual/override/final specifiers.

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 <vector>
 
 #include "ash/session/session_state_delegate.h"
 #include "ash/shell.h"
 #include "ash/shell/example_factory.h"
@@ skipping 37 matching lines @@
     EXAMPLES_WINDOW,
     LAST_TYPE,
   };
 
   explicit WindowTypeShelfItem(const std::string& id, Type type)
       : app_list::AppListItem(id),
         type_(type) {
     std::string title(GetTitle(type));
     SetIcon(GetIcon(type), false);
     SetName(title);
   }

[James Cook, 2014/10/27 23:45:34]

Do you think this class should have ~WindowTypeShelfItem() override {} ?

It doesn't strictly need it -- there are no interesting member variables here --
but that seems like a good pattern to maintain.

[dcheng, 2014/10/27 23:47:55]

If the clang plugin doesn't enforce it, I would argue it's optional =)

However, if you'd like me to add it, I'd be happy to do so in a followup patch.
Let me know if that's OK.

 
   static gfx::ImageSkia GetIcon(Type type) {
     static const SkColor kColors[] = {
         SK_ColorRED,
         SK_ColorGREEN,
         SK_ColorBLUE,
         SK_ColorYELLOW,
         SK_ColorCYAN,
     };
 
@@ skipping 62 matching lines @@
             Shell::GetInstance()->delegate()->GetActiveBrowserContext(),
             NULL);
         break;
       }
       default:
         break;
     }
   }
 
   // AppListItem
-  virtual void Activate(int event_flags) override {
-    ActivateItem(type_, event_flags);
-  }
+  void Activate(int event_flags) override { ActivateItem(type_, event_flags); }
 
  private:
   Type type_;
 
   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
@@ skipping 28 matching lines @@
         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);
   }
 
   WindowTypeShelfItem::Type type() const { return type_; }
 
   // app_list::SearchResult:
-  virtual scoped_ptr<SearchResult> Duplicate() override {
+  scoped_ptr<SearchResult> Duplicate() override {
     return scoped_ptr<SearchResult>();
   }
 
  private:
   WindowTypeShelfItem::Type type_;
 
   DISALLOW_COPY_AND_ASSIGN(ExampleSearchResult);
 };
 
 class ExampleAppListViewDelegate : public app_list::AppListViewDelegate {
@@ skipping 30 matching lines @@
 
     return gfx::ImageSkia(canvas.ExtractImageRep());
   }
 
   void DecorateSearchBox(app_list::SearchBoxModel* search_box_model) {
     search_box_model->SetIcon(CreateSearchBoxIcon());
     search_box_model->SetHintText(base::ASCIIToUTF16("Type to search..."));
   }
 
   // Overridden from app_list::AppListViewDelegate:
-  virtual bool ForceNativeDesktop() const override {
-    return false;
-  }
+  bool ForceNativeDesktop() const override { return false; }
 
-  virtual void SetProfileByPath(const base::FilePath& profile_path) override {
+  void SetProfileByPath(const base::FilePath& profile_path) override {
     // Nothing needs to be done.
   }
 
-  virtual const Users& GetUsers() const override {
-    return users_;
-  }
+  const Users& GetUsers() const override { return users_; }
 
-  virtual bool ShouldCenterWindow() const override {
-    return false;
-  }
+  bool ShouldCenterWindow() const override { return false; }
 
-  virtual app_list::AppListModel* GetModel() override { return model_.get(); }
+  app_list::AppListModel* GetModel() override { return model_.get(); }
 
-  virtual app_list::SpeechUIModel* GetSpeechUI() override {
-    return &speech_ui_;
-  }
+  app_list::SpeechUIModel* GetSpeechUI() override { return &speech_ui_; }
 
-  virtual void GetShortcutPathForApp(
+  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,
-                                bool auto_launch,
-                                int event_flags) override {
+  void OpenSearchResult(app_list::SearchResult* result,
+                        bool auto_launch,
+                        int event_flags) override {
     const ExampleSearchResult* example_result =
         static_cast<const ExampleSearchResult*>(result);
     WindowTypeShelfItem::ActivateItem(example_result->type(), event_flags);
   }
 
-  virtual void InvokeSearchResultAction(app_list::SearchResult* result,
-                                        int action_index,
-                                        int event_flags) override {
+  void InvokeSearchResultAction(app_list::SearchResult* result,
+                                int action_index,
+                                int event_flags) override {
     NOTIMPLEMENTED();
   }
 
-  virtual base::TimeDelta GetAutoLaunchTimeout() override {
-    return base::TimeDelta();
-  }
+  base::TimeDelta GetAutoLaunchTimeout() override { return base::TimeDelta(); }
 
-  virtual void AutoLaunchCanceled() override {
-  }
+  void AutoLaunchCanceled() override {}
 
-  virtual void StartSearch() override {
+  void StartSearch() override {
     base::string16 query;
     base::TrimWhitespace(model_->search_box()->text(), base::TRIM_ALL, &query);
     query = base::i18n::ToLower(query);
 
     model_->results()->DeleteAll();
     if (query.empty())
       return;
 
     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(WindowTypeShelfItem::GetTitle(type));
       if (base::i18n::StringSearchIgnoringCaseAndAccents(
               query, title, NULL, NULL)) {
         model_->results()->Add(new ExampleSearchResult(type, query));
       }
     }
   }
 
-  virtual void StopSearch() override {
+  void StopSearch() override {
     // Nothing needs to be done.
   }
 
-  virtual void ViewInitialized() override {
+  void ViewInitialized() override {
     // Nothing needs to be done.
   }
 
-  virtual void Dismiss() override {
+  void Dismiss() override {
     DCHECK(ash::Shell::HasInstance());
     Shell::GetInstance()->DismissAppList();
   }
 
-  virtual void ViewClosing() override {
+  void ViewClosing() override {
     // Nothing needs to be done.
   }
 
-  virtual gfx::ImageSkia GetWindowIcon() override {
-    return gfx::ImageSkia();
-  }
+  gfx::ImageSkia GetWindowIcon() override { return gfx::ImageSkia(); }
 
-  virtual void OpenSettings() override {
+  void OpenSettings() override {
     // Nothing needs to be done.
   }
 
-  virtual void OpenHelp() override {
+  void OpenHelp() override {
     // Nothing needs to be done.
   }
 
-  virtual void OpenFeedback() override {
+  void OpenFeedback() override {
     // Nothing needs to be done.
   }
 
-  virtual void ToggleSpeechRecognition() override {
-    NOTIMPLEMENTED();
-  }
+  void ToggleSpeechRecognition() override { NOTIMPLEMENTED(); }
 
-  virtual void ShowForProfileByPath(
-      const base::FilePath& profile_path) override {
+  void ShowForProfileByPath(const base::FilePath& profile_path) override {
     // Nothing needs to be done.
   }
 
-  virtual views::View* CreateStartPageWebView(const gfx::Size& size) override {
+  views::View* CreateStartPageWebView(const gfx::Size& size) override {
     return NULL;
   }
 
-  virtual std::vector<views::View*> CreateCustomPageWebViews(
+  std::vector<views::View*> CreateCustomPageWebViews(
       const gfx::Size& size) override {
     return std::vector<views::View*>();
   }
 
-  virtual bool IsSpeechRecognitionEnabled() override {
-    return false;
-  }
+  bool IsSpeechRecognitionEnabled() override { return false; }
 
   scoped_ptr<app_list::AppListModel> model_;
   app_list::SpeechUIModel speech_ui_;
   Users users_;
 
   DISALLOW_COPY_AND_ASSIGN(ExampleAppListViewDelegate);
 };
 
 }  // namespace
 
 app_list::AppListViewDelegate* CreateAppListViewDelegate() {
   return new ExampleAppListViewDelegate;
 }
 
 }  // namespace shell
 }  // namespace ash