Renamed speech input implementation from to speech_recognition_*. The namespace has been renamed fr…

chrome/browser/speech/speech_recognition_bubble_gtk.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/speech/speech_input_bubble.h"
+#include "chrome/browser/speech/speech_recognition_bubble.h"
 
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/gtk/browser_toolbar_gtk.h"
 #include "chrome/browser/ui/gtk/browser_window_gtk.h"
 #include "chrome/browser/ui/gtk/bubble/bubble_gtk.h"
 #include "chrome/browser/ui/gtk/gtk_chrome_link_button.h"
 #include "chrome/browser/ui/gtk/gtk_util.h"
 #include "chrome/browser/ui/gtk/location_bar_view_gtk.h"
 #include "chrome/browser/ui/gtk/theme_service_gtk.h"
 #include "content/public/browser/resource_context.h"
-#include "content/public/browser/speech_input_manager.h"
+#include "content/public/browser/speech_recognition_manager.h"
 #include "content/public/browser/web_contents.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "ui/base/gtk/gtk_hig_constants.h"
 #include "ui/base/gtk/owned_widget_gtk.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/gtk_util.h"
 #include "ui/gfx/rect.h"
 
 using content::WebContents;
 
 namespace {
 
 const int kBubbleControlVerticalSpacing = 5;
 const int kBubbleControlHorizontalSpacing = 20;
 const int kIconHorizontalPadding = 10;
 const int kButtonBarHorizontalSpacing = 10;
 
 // Use black for text labels since the bubble has white background.
 const GdkColor& kLabelTextColor = ui::kGdkBlack;
 
-// Implementation of SpeechInputBubble for GTK. This shows a speech input bubble
-// on screen.
-class SpeechInputBubbleGtk : public SpeechInputBubbleBase,
-                             public BubbleDelegateGtk {
+// Implementation of SpeechRecognitionBubble for GTK. This shows a speech
+// recognition bubble on screen.
+class SpeechRecognitionBubbleGtk : public SpeechRecognitionBubbleBase,
+                                   public BubbleDelegateGtk {
  public:
-  SpeechInputBubbleGtk(WebContents* web_contents,
-                       Delegate* delegate,
-                       const gfx::Rect& element_rect);
-  ~SpeechInputBubbleGtk();
+  SpeechRecognitionBubbleGtk(WebContents* web_contents,
+                             Delegate* delegate,
+                             const gfx::Rect& element_rect);
+  ~SpeechRecognitionBubbleGtk();
 
  private:
-  // SpeechInputBubbleBase:
+  // SpeechRecognitionBubbleBase:
   virtual void Show() OVERRIDE;
   virtual void Hide() OVERRIDE;
   virtual void UpdateLayout() OVERRIDE;
   virtual void UpdateImage() OVERRIDE;
 
   // BubbleDelegateGtk:
   virtual void BubbleClosing(BubbleGtk* bubble, bool closed_by_escape) OVERRIDE;
 
-  CHROMEGTK_CALLBACK_0(SpeechInputBubbleGtk, void, OnCancelClicked);
-  CHROMEGTK_CALLBACK_0(SpeechInputBubbleGtk, void, OnTryAgainClicked);
-  CHROMEGTK_CALLBACK_0(SpeechInputBubbleGtk, void, OnMicSettingsClicked);
+  CHROMEGTK_CALLBACK_0(SpeechRecognitionBubbleGtk, void, OnCancelClicked);
+  CHROMEGTK_CALLBACK_0(SpeechRecognitionBubbleGtk, void, OnTryAgainClicked);
+  CHROMEGTK_CALLBACK_0(SpeechRecognitionBubbleGtk, void, OnMicSettingsClicked);
 
   Delegate* delegate_;
   BubbleGtk* bubble_;
   gfx::Rect element_rect_;
   bool did_invoke_close_;
 
   GtkWidget* label_;
   GtkWidget* cancel_button_;
   GtkWidget* try_again_button_;
   GtkWidget* icon_;
   GtkWidget* icon_container_;
   GtkWidget* mic_settings_;
 
-  DISALLOW_COPY_AND_ASSIGN(SpeechInputBubbleGtk);
+  DISALLOW_COPY_AND_ASSIGN(SpeechRecognitionBubbleGtk);
 };
 
-SpeechInputBubbleGtk::SpeechInputBubbleGtk(WebContents* web_contents,
-                                           Delegate* delegate,
-                                           const gfx::Rect& element_rect)
-    : SpeechInputBubbleBase(web_contents),
+SpeechRecognitionBubbleGtk::SpeechRecognitionBubbleGtk(
+    WebContents* web_contents, Delegate* delegate,
+    const gfx::Rect& element_rect)
+    : SpeechRecognitionBubbleBase(web_contents),
       delegate_(delegate),
       bubble_(NULL),
       element_rect_(element_rect),
       did_invoke_close_(false),
       label_(NULL),
       cancel_button_(NULL),
       try_again_button_(NULL),
       icon_(NULL),
       icon_container_(NULL),
       mic_settings_(NULL) {
 }
 
-SpeechInputBubbleGtk::~SpeechInputBubbleGtk() {
+SpeechRecognitionBubbleGtk::~SpeechRecognitionBubbleGtk() {
   // The |Close| call below invokes our |BubbleClosing| method. Since we were
   // destroyed by the caller we don't need to call them back, hence set this
   // flag here.
   did_invoke_close_ = true;
   Hide();
 }
 
-void SpeechInputBubbleGtk::OnCancelClicked(GtkWidget* widget) {
+void SpeechRecognitionBubbleGtk::OnCancelClicked(GtkWidget* widget) {
   delegate_->InfoBubbleButtonClicked(BUTTON_CANCEL);
 }
 
-void SpeechInputBubbleGtk::OnTryAgainClicked(GtkWidget* widget) {
+void SpeechRecognitionBubbleGtk::OnTryAgainClicked(GtkWidget* widget) {
   delegate_->InfoBubbleButtonClicked(BUTTON_TRY_AGAIN);
 }
 
-void SpeechInputBubbleGtk::OnMicSettingsClicked(GtkWidget* widget) {
-  content::SpeechInputManager::GetInstance()->ShowAudioInputSettings();
+void SpeechRecognitionBubbleGtk::OnMicSettingsClicked(GtkWidget* widget) {
+  content::SpeechRecognitionManager::GetInstance()->ShowAudioInputSettings();
   Hide();
 }
 
-void SpeechInputBubbleGtk::Show() {
+void SpeechRecognitionBubbleGtk::Show() {
   if (bubble_)
     return;  // Nothing further to do since the bubble is already visible.
 
   // We use a vbox to arrange the controls (label, image, button bar) vertically
   // and the button bar is a hbox holding the 2 buttons (try again and cancel).
   // To get horizontal space around them we place this vbox with padding in a
   // GtkAlignment below.
   GtkWidget* vbox = gtk_vbox_new(FALSE, 0);
 
   // The icon with a some padding on the left and right.
@@ skipping 71 matching lines @@
                             content,
                             BubbleGtk::ARROW_LOCATION_TOP_LEFT,
                             false,  // match_system_theme
                             true,  // grab_input
                             theme_provider,
                             this);
 
   UpdateLayout();
 }
 
-void SpeechInputBubbleGtk::Hide() {
+void SpeechRecognitionBubbleGtk::Hide() {
   if (bubble_)
     bubble_->Close();
 }
 
-void SpeechInputBubbleGtk::UpdateLayout() {
+void SpeechRecognitionBubbleGtk::UpdateLayout() {
   if (!bubble_)
     return;
 
   if (display_mode() == DISPLAY_MODE_MESSAGE) {
     // Message text and the Try Again + Cancel buttons are visible, hide the
     // icon.
     gtk_label_set_text(GTK_LABEL(label_),
                        UTF16ToUTF8(message_text()).c_str());
     gtk_widget_show(label_);
     gtk_widget_show(try_again_button_);
@@ skipping 41 matching lines @@
                                 diff_width / 2, diff_width - diff_width / 2);
     } else {
       // Reset the padding done above.
       gtk_alignment_set_padding(GTK_ALIGNMENT(icon_container_), 0, 0,
                                 kIconHorizontalPadding, kIconHorizontalPadding);
       gtk_widget_show(cancel_button_);
     }
   }
 }
 
-void SpeechInputBubbleGtk::UpdateImage() {
+void SpeechRecognitionBubbleGtk::UpdateImage() {
   SkBitmap image = icon_image();
   if (image.isNull() || !bubble_)
     return;
 
   GdkPixbuf* pixbuf = gfx::GdkPixbufFromSkBitmap(&image);
   gtk_image_set_from_pixbuf(GTK_IMAGE(icon_), pixbuf);
   g_object_unref(pixbuf);
 }
 
-void SpeechInputBubbleGtk::BubbleClosing(BubbleGtk* bubble,
-                                         bool closed_by_escape) {
+void SpeechRecognitionBubbleGtk::BubbleClosing(BubbleGtk* bubble,
+                                               bool closed_by_escape) {
   bubble_ = NULL;
   if (!did_invoke_close_)
     delegate_->InfoBubbleFocusChanged();
 }
 
 }  // namespace
 
-SpeechInputBubble* SpeechInputBubble::CreateNativeBubble(
+SpeechRecognitionBubble* SpeechRecognitionBubble::CreateNativeBubble(
     WebContents* web_contents,
     Delegate* delegate,
     const gfx::Rect& element_rect) {
-  return new SpeechInputBubbleGtk(web_contents, delegate, element_rect);
+  return new SpeechRecognitionBubbleGtk(web_contents, delegate, element_rect);
 }