Tab, TabStrip: Added GetClassName override.

ui/views/controls/tabbed_pane/tabbed_pane.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 "ui/views/controls/tabbed_pane/tabbed_pane.h"
 
 #include "base/logging.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/events/keycodes/keyboard_codes.h"
@@ skipping 16 matching lines @@
 }  // namespace
 
 namespace views {
 
 // static
 const char TabbedPane::kViewClassName[] = "TabbedPane";
 
 // The tab view shown in the tab strip.
 class Tab : public View {
  public:
+  // Internal class name.
+  static const char kViewClassName[];
+
   Tab(TabbedPane* tabbed_pane, const base::string16& title, View* contents);
   ~Tab() override;
 
   View* contents() const { return contents_; }
 
   bool selected() const { return contents_->visible(); }
   void SetSelected(bool selected);
 
   // Overridden from View:
   bool OnMousePressed(const ui::MouseEvent& event) override;
   void OnMouseEntered(const ui::MouseEvent& event) override;
   void OnMouseExited(const ui::MouseEvent& event) override;
   void OnGestureEvent(ui::GestureEvent* event) override;
   gfx::Size GetPreferredSize() const override;
   void Layout() override;
+  const char* GetClassName() const override;
 
  private:
   enum TabState {
     TAB_INACTIVE,
     TAB_ACTIVE,
     TAB_HOVERED,
   };
 
   void SetState(TabState tab_state);
 
   TabbedPane* tabbed_pane_;
   Label* title_;
   gfx::Size preferred_title_size_;
   TabState tab_state_;
   // The content view associated with this tab.
   View* contents_;
 
   DISALLOW_COPY_AND_ASSIGN(Tab);
 };
 
 // The tab strip shown above the tab contents.
 class TabStrip : public View {
  public:
+  // Internal class name.
+  static const char kViewClassName[];
+
   explicit TabStrip(TabbedPane* tabbed_pane);
   ~TabStrip() override;
 
   // Overridden from View:
   gfx::Size GetPreferredSize() const override;
   void Layout() override;
+  const char* GetClassName() const override;
   void OnPaint(gfx::Canvas* canvas) override;
 
  private:
   TabbedPane* tabbed_pane_;
 
   DISALLOW_COPY_AND_ASSIGN(TabStrip);
 };
 
+// static
+const char Tab::kViewClassName[] = "Tab";
+
 Tab::Tab(TabbedPane* tabbed_pane, const base::string16& title, View* contents)
     : tabbed_pane_(tabbed_pane),
       title_(new Label(title,
                        ui::ResourceBundle::GetSharedInstance().GetFontList(
                            ui::ResourceBundle::BoldFont))),
       tab_state_(TAB_ACTIVE),
       contents_(contents) {
   // Calculate this now while the font list is guaranteed to be bold.
   preferred_title_size_ = title_->GetPreferredSize();
 
@@ skipping 49 matching lines @@
   return size;
 }
 
 void Tab::Layout() {
   gfx::Rect bounds = GetLocalBounds();
   bounds.Inset(0, 1, 0, 0);
   bounds.ClampToCenteredSize(preferred_title_size_);
   title_->SetBoundsRect(bounds);
 }
 
+const char* Tab::GetClassName() const {
+  return kViewClassName;
+}
+
 void Tab::SetState(TabState tab_state) {
   if (tab_state == tab_state_)
     return;
   tab_state_ = tab_state;
 
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   switch (tab_state) {
     case TAB_INACTIVE:
       title_->SetEnabledColor(kTabTitleColor_Inactive);
       title_->SetFontList(rb.GetFontList(ui::ResourceBundle::BaseFont));
       break;
     case TAB_ACTIVE:
       title_->SetEnabledColor(kTabTitleColor_Active);
       title_->SetFontList(rb.GetFontList(ui::ResourceBundle::BoldFont));
       break;
     case TAB_HOVERED:
       title_->SetEnabledColor(kTabTitleColor_Hovered);
       title_->SetFontList(rb.GetFontList(ui::ResourceBundle::BaseFont));
       break;
   }
   SchedulePaint();
 }
 
+// static
+const char TabStrip::kViewClassName[] = "TabStrip";
+
 TabStrip::TabStrip(TabbedPane* tabbed_pane) : tabbed_pane_(tabbed_pane) {}
 
 TabStrip::~TabStrip() {}
 
 gfx::Size TabStrip::GetPreferredSize() const {
   gfx::Size size;
   for (int i = 0; i < child_count(); ++i) {
     const gfx::Size child_size = child_at(i)->GetPreferredSize();
     size.SetSize(size.width() + child_size.width(),
                  std::max(size.height(), child_size.height()));
   }
   return size;
 }
 
 void TabStrip::Layout() {
   const int kTabOffset = 9;
   int x = kTabOffset;  // Layout tabs with an offset to the tabstrip border.
   for (int i = 0; i < child_count(); ++i) {
     gfx::Size ps = child_at(i)->GetPreferredSize();
     child_at(i)->SetBounds(x, 0, ps.width(), ps.height());
     x = child_at(i)->bounds().right();
   }
 }
 
+const char* TabStrip::GetClassName() const {
+  return kViewClassName;
+}
+
 void TabStrip::OnPaint(gfx::Canvas* canvas) {
   OnPaintBackground(canvas);
 
   // Draw the TabStrip border.
   SkPaint paint;
   paint.setColor(kTabBorderColor);
   paint.setStrokeWidth(kTabBorderThickness);
   SkScalar line_y = SkIntToScalar(height()) - (kTabBorderThickness / 2);
   SkScalar line_end = SkIntToScalar(width());
   int selected_tab_index = tabbed_pane_->selected_tab_index();
@@ skipping 151 matching lines @@
     selected_tab->NotifyAccessibilityEvent(
         ui::AX_EVENT_FOCUS, true);
   }
 }
 
 void TabbedPane::GetAccessibleState(ui::AXViewState* state) {
   state->role = ui::AX_ROLE_TAB_LIST;
 }
 
 }  // namespace views