| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "chrome/browser/speech/speech_input_bubble_controller.h" | |
| 6 | |
| 7 #include "base/bind.h" | |
| 8 #include "chrome/browser/tab_contents/tab_util.h" | |
| 9 #include "content/public/browser/browser_thread.h" | |
| 10 #include "content/public/browser/notification_registrar.h" | |
| 11 #include "content/public/browser/notification_source.h" | |
| 12 #include "content/public/browser/notification_types.h" | |
| 13 #include "content/public/browser/web_contents.h" | |
| 14 #include "ui/gfx/rect.h" | |
| 15 | |
| 16 using content::BrowserThread; | |
| 17 using content::WebContents; | |
| 18 | |
| 19 namespace speech_input { | |
| 20 | |
| 21 SpeechInputBubbleController::SpeechInputBubbleController(Delegate* delegate) | |
| 22 : delegate_(delegate), | |
| 23 current_bubble_caller_id_(0), | |
| 24 registrar_(new content::NotificationRegistrar) { | |
| 25 } | |
| 26 | |
| 27 SpeechInputBubbleController::~SpeechInputBubbleController() { | |
| 28 DCHECK(bubbles_.empty()); | |
| 29 } | |
| 30 | |
| 31 void SpeechInputBubbleController::CreateBubble(int caller_id, | |
| 32 int render_process_id, | |
| 33 int render_view_id, | |
| 34 const gfx::Rect& element_rect) { | |
| 35 if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) { | |
| 36 BrowserThread::PostTask( | |
| 37 BrowserThread::UI, FROM_HERE, | |
| 38 base::Bind(&SpeechInputBubbleController::CreateBubble, this, | |
| 39 caller_id, render_process_id, render_view_id, | |
| 40 element_rect)); | |
| 41 return; | |
| 42 } | |
| 43 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 44 WebContents* web_contents = tab_util::GetWebContentsByID(render_process_id, | |
| 45 render_view_id); | |
| 46 | |
| 47 DCHECK_EQ(0u, bubbles_.count(caller_id)); | |
| 48 SpeechInputBubble* bubble = SpeechInputBubble::Create(web_contents, this, | |
| 49 element_rect); | |
| 50 if (!bubble) { | |
| 51 // Could be null if tab or display rect were invalid. | |
| 52 // Simulate the cancel button being clicked to inform the delegate. | |
| 53 BrowserThread::PostTask( | |
| 54 BrowserThread::IO, FROM_HERE, | |
| 55 base::Bind( | |
| 56 &SpeechInputBubbleController::InvokeDelegateButtonClicked, | |
| 57 this, caller_id, SpeechInputBubble::BUTTON_CANCEL)); | |
| 58 return; | |
| 59 } | |
| 60 | |
| 61 bubbles_[caller_id] = bubble; | |
| 62 | |
| 63 UpdateTabContentsSubscription(caller_id, BUBBLE_ADDED); | |
| 64 } | |
| 65 | |
| 66 void SpeechInputBubbleController::CloseBubble(int caller_id) { | |
| 67 ProcessRequestInUiThread(caller_id, REQUEST_CLOSE, string16(), 0, 0); | |
| 68 } | |
| 69 | |
| 70 void SpeechInputBubbleController::SetBubbleWarmUpMode(int caller_id) { | |
| 71 ProcessRequestInUiThread(caller_id, REQUEST_SET_WARM_UP_MODE, | |
| 72 string16(), 0, 0); | |
| 73 } | |
| 74 | |
| 75 void SpeechInputBubbleController::SetBubbleRecordingMode(int caller_id) { | |
| 76 ProcessRequestInUiThread(caller_id, REQUEST_SET_RECORDING_MODE, | |
| 77 string16(), 0, 0); | |
| 78 } | |
| 79 | |
| 80 void SpeechInputBubbleController::SetBubbleRecognizingMode(int caller_id) { | |
| 81 ProcessRequestInUiThread(caller_id, REQUEST_SET_RECOGNIZING_MODE, | |
| 82 string16(), 0, 0); | |
| 83 } | |
| 84 | |
| 85 void SpeechInputBubbleController::SetBubbleInputVolume(int caller_id, | |
| 86 float volume, | |
| 87 float noise_volume) { | |
| 88 ProcessRequestInUiThread(caller_id, REQUEST_SET_INPUT_VOLUME, string16(), | |
| 89 volume, noise_volume); | |
| 90 } | |
| 91 | |
| 92 void SpeechInputBubbleController::SetBubbleMessage(int caller_id, | |
| 93 const string16& text) { | |
| 94 ProcessRequestInUiThread(caller_id, REQUEST_SET_MESSAGE, text, 0, 0); | |
| 95 } | |
| 96 | |
| 97 void SpeechInputBubbleController::UpdateTabContentsSubscription( | |
| 98 int caller_id, ManageSubscriptionAction action) { | |
| 99 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 100 | |
| 101 // If there are any other bubbles existing for the same TabContents, we would | |
| 102 // have subscribed to tab close notifications on their behalf and we need to | |
| 103 // stay registered. So we don't change the subscription in such cases. | |
| 104 WebContents* web_contents = bubbles_[caller_id]->web_contents(); | |
| 105 for (BubbleCallerIdMap::iterator iter = bubbles_.begin(); | |
| 106 iter != bubbles_.end(); ++iter) { | |
| 107 if (iter->second->web_contents() == web_contents && | |
| 108 iter->first != caller_id) { | |
| 109 // At least one other bubble exists for the same TabContents. So don't | |
| 110 // make any change to the subscription. | |
| 111 return; | |
| 112 } | |
| 113 } | |
| 114 | |
| 115 if (action == BUBBLE_ADDED) { | |
| 116 registrar_->Add(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED, | |
| 117 content::Source<WebContents>(web_contents)); | |
| 118 } else { | |
| 119 registrar_->Remove(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED, | |
| 120 content::Source<WebContents>(web_contents)); | |
| 121 } | |
| 122 } | |
| 123 | |
| 124 void SpeechInputBubbleController::Observe( | |
| 125 int type, | |
| 126 const content::NotificationSource& source, | |
| 127 const content::NotificationDetails& details) { | |
| 128 if (type == content::NOTIFICATION_WEB_CONTENTS_DESTROYED) { | |
| 129 // Cancel all bubbles and active recognition sessions for this tab. | |
| 130 WebContents* web_contents = content::Source<WebContents>(source).ptr(); | |
| 131 BubbleCallerIdMap::iterator iter = bubbles_.begin(); | |
| 132 while (iter != bubbles_.end()) { | |
| 133 if (iter->second->web_contents() == web_contents) { | |
| 134 BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, | |
| 135 base::Bind( | |
| 136 &SpeechInputBubbleController::InvokeDelegateButtonClicked, | |
| 137 this, iter->first, SpeechInputBubble::BUTTON_CANCEL)); | |
| 138 CloseBubble(iter->first); | |
| 139 // We expect to have a very small number of items in this map so | |
| 140 // redo-ing from start is ok. | |
| 141 iter = bubbles_.begin(); | |
| 142 } else { | |
| 143 ++iter; | |
| 144 } | |
| 145 } | |
| 146 } else { | |
| 147 NOTREACHED() << "Unknown notification"; | |
| 148 } | |
| 149 } | |
| 150 | |
| 151 void SpeechInputBubbleController::ProcessRequestInUiThread( | |
| 152 int caller_id, RequestType type, const string16& text, float volume, | |
| 153 float noise_volume) { | |
| 154 if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) { | |
| 155 BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind( | |
| 156 &SpeechInputBubbleController::ProcessRequestInUiThread, this, | |
| 157 caller_id, type, text, volume, noise_volume)); | |
| 158 return; | |
| 159 } | |
| 160 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 161 // The bubble may have been closed before we got a chance to process this | |
| 162 // request. So check before proceeding. | |
| 163 if (!bubbles_.count(caller_id)) | |
| 164 return; | |
| 165 | |
| 166 bool change_active_bubble = (type == REQUEST_SET_WARM_UP_MODE || | |
| 167 type == REQUEST_SET_MESSAGE); | |
| 168 if (change_active_bubble) { | |
| 169 if (current_bubble_caller_id_ && current_bubble_caller_id_ != caller_id) | |
| 170 bubbles_[current_bubble_caller_id_]->Hide(); | |
| 171 current_bubble_caller_id_ = caller_id; | |
| 172 } | |
| 173 | |
| 174 SpeechInputBubble* bubble = bubbles_[caller_id]; | |
| 175 switch (type) { | |
| 176 case REQUEST_SET_WARM_UP_MODE: | |
| 177 bubble->SetWarmUpMode(); | |
| 178 break; | |
| 179 case REQUEST_SET_RECORDING_MODE: | |
| 180 bubble->SetRecordingMode(); | |
| 181 break; | |
| 182 case REQUEST_SET_RECOGNIZING_MODE: | |
| 183 bubble->SetRecognizingMode(); | |
| 184 break; | |
| 185 case REQUEST_SET_MESSAGE: | |
| 186 bubble->SetMessage(text); | |
| 187 break; | |
| 188 case REQUEST_SET_INPUT_VOLUME: | |
| 189 bubble->SetInputVolume(volume, noise_volume); | |
| 190 break; | |
| 191 case REQUEST_CLOSE: | |
| 192 if (current_bubble_caller_id_ == caller_id) | |
| 193 current_bubble_caller_id_ = 0; | |
| 194 UpdateTabContentsSubscription(caller_id, BUBBLE_REMOVED); | |
| 195 delete bubble; | |
| 196 bubbles_.erase(caller_id); | |
| 197 break; | |
| 198 default: | |
| 199 NOTREACHED(); | |
| 200 break; | |
| 201 } | |
| 202 | |
| 203 if (change_active_bubble) | |
| 204 bubble->Show(); | |
| 205 } | |
| 206 | |
| 207 void SpeechInputBubbleController::InfoBubbleButtonClicked( | |
| 208 SpeechInputBubble::Button button) { | |
| 209 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 210 DCHECK(current_bubble_caller_id_); | |
| 211 | |
| 212 BrowserThread::PostTask( | |
| 213 BrowserThread::IO, FROM_HERE, | |
| 214 base::Bind( | |
| 215 &SpeechInputBubbleController::InvokeDelegateButtonClicked, | |
| 216 this, current_bubble_caller_id_, button)); | |
| 217 } | |
| 218 | |
| 219 void SpeechInputBubbleController::InfoBubbleFocusChanged() { | |
| 220 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); | |
| 221 DCHECK(current_bubble_caller_id_); | |
| 222 | |
| 223 int old_bubble_caller_id = current_bubble_caller_id_; | |
| 224 current_bubble_caller_id_ = 0; | |
| 225 | |
| 226 BrowserThread::PostTask( | |
| 227 BrowserThread::IO, FROM_HERE, | |
| 228 base::Bind( | |
| 229 &SpeechInputBubbleController::InvokeDelegateFocusChanged, | |
| 230 this, old_bubble_caller_id)); | |
| 231 } | |
| 232 | |
| 233 void SpeechInputBubbleController::InvokeDelegateButtonClicked( | |
| 234 int caller_id, SpeechInputBubble::Button button) { | |
| 235 delegate_->InfoBubbleButtonClicked(caller_id, button); | |
| 236 } | |
| 237 | |
| 238 void SpeechInputBubbleController::InvokeDelegateFocusChanged(int caller_id) { | |
| 239 delegate_->InfoBubbleFocusChanged(caller_id); | |
| 240 } | |
| 241 | |
| 242 } // namespace speech_input | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 9568002:
Renamed speech input implementation from to speech_recognition_*. The namespace has been renamed fr… (Closed)
Base URL: http://git.chromium.org/chromium/src.git@master