Fix some UI issues with omnibox extensions in incognito.

chrome/browser/autocomplete/keyword_provider.cc

 // Copyright (c) 2010 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/autocomplete/keyword_provider.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "app/l10n_util.h"
@@ skipping 150 matching lines @@
   // |minimal_changes| case, but since we'd still have to recalculate their
   // relevances and we can just recreate the results synchronously anyway, we
   // don't bother.
   //
   // TODO(pkasting): http://b/893701 We should remember the user's use of a
   // search query both from the autocomplete popup and from web pages
   // themselves.
   std::vector<std::wstring> keyword_matches;
   model->FindMatchingKeywords(keyword, !remaining_input.empty(),
                               &keyword_matches);
+
+  // Prune any extension keywords that are disallowed in incognito mode (if
+  // we're incognito), or disabled.
+  for (std::vector<std::wstring>::iterator i(keyword_matches.begin());
+       i != keyword_matches.end(); ) {
+    const TemplateURL* template_url(model->GetTemplateURLForKeyword(*i));
+    if (profile_ &&
+        !input.synchronous_only() && template_url->IsExtensionKeyword()) {
+      ExtensionsService* service = profile_->GetExtensionsService();
+      const Extension* extension = service->GetExtensionById(
+          template_url->GetExtensionId(), false);
+      bool enabled = extension && (!profile_->IsOffTheRecord() ||
+                                   service->IsIncognitoEnabled(extension));
+      if (!enabled) {
+        i = keyword_matches.erase(i);
+        continue;
+      }
+    }
+    ++i;
+  }
   if (keyword_matches.empty())
     return;
   std::sort(keyword_matches.begin(), keyword_matches.end(), CompareQuality());
 
   // Limit to one exact or three inexact matches, and mark them up for display
   // in the autocomplete popup.
   // Any exact match is going to be the highest quality match, and thus at the
   // front of our vector.
   if (keyword_matches.front() == keyword) {
     const TemplateURL* template_url(model->GetTemplateURLForKeyword(keyword));
     // TODO(pkasting): We should probably check that if the user explicitly
     // typed a scheme, that scheme matches the one in |template_url|.
+    matches_.push_back(CreateAutocompleteMatch(model, keyword, input,
+                                               keyword.length(),
+                                               remaining_input, -1));
 
     if (profile_ &&
         !input.synchronous_only() && template_url->IsExtensionKeyword()) {
-      // If this extension keyword is disabled, make sure we don't add any
-      // matches (including the synchronous one below).
-      ExtensionsService* service = profile_->GetExtensionsService();
-      const Extension* extension = service->GetExtensionById(
-          template_url->GetExtensionId(), false);
-      bool enabled = extension && (!profile_->IsOffTheRecord() ||
-                                   service->IsIncognitoEnabled(extension));
-      if (!enabled)
-        return;
-
-      if (extension->id() != current_keyword_extension_id_)
+      if (template_url->GetExtensionId() != current_keyword_extension_id_)
         MaybeEndExtensionKeywordMode();
       if (current_keyword_extension_id_.empty())
-        EnterExtensionKeywordMode(extension->id());
+        EnterExtensionKeywordMode(template_url->GetExtensionId());
       keyword_mode_toggle.StayInKeywordMode();
 
       if (minimal_changes) {
         // If the input hasn't significantly changed, we can just use the
         // suggestions from last time. We need to readjust the relevance to
         // ensure it is less than the main match's relevance.
         for (size_t i = 0; i < extension_suggest_matches_.size(); ++i) {
           matches_.push_back(extension_suggest_matches_[i]);
           matches_.back().relevance = matches_[0].relevance - (i + 1);
         }
       } else {
         extension_suggest_last_input_ = input;
         extension_suggest_matches_.clear();
 
         bool have_listeners = ExtensionOmniboxEventRouter::OnInputChanged(
             profile_, template_url->GetExtensionId(),
             WideToUTF8(remaining_input), current_input_id_);
 
         // We only have to wait for suggest results if there are actually
         // extensions listening for input changes.
         if (have_listeners)
           done_ = false;
       }
     }
-
-    matches_.push_back(CreateAutocompleteMatch(model, keyword, input,
-                                               keyword.length(),
-                                               remaining_input, -1));
   } else {
     if (keyword_matches.size() > kMaxMatches) {
       keyword_matches.erase(keyword_matches.begin() + kMaxMatches,
                             keyword_matches.end());
     }
     for (std::vector<std::wstring>::const_iterator i(keyword_matches.begin());
          i != keyword_matches.end(); ++i) {
       matches_.push_back(CreateAutocompleteMatch(model, *i, input,
                                                  keyword.length(),
                                                  remaining_input, -1));
@@ skipping 233 matching lines @@
 }
 
 void KeywordProvider::MaybeEndExtensionKeywordMode() {
   if (!current_keyword_extension_id_.empty()) {
     ExtensionOmniboxEventRouter::OnInputCancelled(
         profile_, current_keyword_extension_id_);
 
     current_keyword_extension_id_.clear();
   }
 }