Moving extensions inside chrome/browser/extensions/

chrome/browser/autocomplete/keyword_provider.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/autocomplete/keyword_provider.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/string16.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
-#include "chrome/browser/extensions/extension_omnibox_api.h"
+#include "chrome/browser/extensions/api/omnibox/omnibox_api.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "grit/generated_resources.h"
 #include "net/base/escape.h"
@@ skipping 263 matching lines @@
 
     if (profile_ && template_url->IsExtensionKeyword()) {
       if (input.matches_requested() == AutocompleteInput::ALL_MATCHES) {
         if (template_url->GetExtensionId() != current_keyword_extension_id_)
           MaybeEndExtensionKeywordMode();
         if (current_keyword_extension_id_.empty())
           EnterExtensionKeywordMode(template_url->GetExtensionId());
         keyword_mode_toggle.StayInKeywordMode();
       }
 
-      ApplyDefaultSuggestionForExtensionKeyword(profile_, template_url,
-                                                remaining_input,
-                                                &matches_[0]);
+      extensions::ApplyDefaultSuggestionForExtensionKeyword(
+          profile_, template_url,
+          remaining_input,
+          &matches_[0]);
 
       if (minimal_changes &&
           (input.matches_requested() != AutocompleteInput::BEST_MATCH)) {
         // 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 if (input.matches_requested() == AutocompleteInput::ALL_MATCHES) {
         extension_suggest_last_input_ = input;
         extension_suggest_matches_.clear();
 
-        bool have_listeners = ExtensionOmniboxEventRouter::OnInputChanged(
-            profile_, template_url->GetExtensionId(),
-            UTF16ToUTF8(remaining_input), current_input_id_);
+        bool have_listeners =
+          extensions::ExtensionOmniboxEventRouter::OnInputChanged(
+              profile_, template_url->GetExtensionId(),
+              UTF16ToUTF8(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;
       }
     }
   } else {
     if (keyword_matches.size() > kMaxMatches) {
       keyword_matches.erase(keyword_matches.begin() + kMaxMatches,
@@ skipping 170 matching lines @@
     case chrome::NOTIFICATION_EXTENSION_OMNIBOX_DEFAULT_SUGGESTION_CHANGED: {
       // It's possible to change the default suggestion while not in an editing
       // session.
       string16 keyword, remaining_input;
       if (matches_.empty() || current_keyword_extension_id_.empty() ||
           !ExtractKeywordFromInput(input, &keyword, &remaining_input))
         return;
 
       const TemplateURL* template_url(
           model->GetTemplateURLForKeyword(keyword));
-      ApplyDefaultSuggestionForExtensionKeyword(profile_, template_url,
-                                                remaining_input,
-                                                &matches_[0]);
+      extensions::ApplyDefaultSuggestionForExtensionKeyword(
+          profile_, template_url,
+          remaining_input,
+          &matches_[0]);
       listener_->OnProviderUpdate(true);
       return;
     }
 
     case chrome::NOTIFICATION_EXTENSION_OMNIBOX_SUGGESTIONS_READY: {
-      const ExtensionOmniboxSuggestions& suggestions =
-        *content::Details<ExtensionOmniboxSuggestions>(details).ptr();
+      const extensions::ExtensionOmniboxSuggestions& suggestions =
+        *content::Details<
+            extensions::ExtensionOmniboxSuggestions>(details).ptr();
       if (suggestions.request_id != current_input_id_)
         return;  // This is an old result. Just ignore.
 
       string16 keyword, remaining_input;
       if (!ExtractKeywordFromInput(input, &keyword, &remaining_input)) {
         NOTREACHED();
         return;
       }
 
       // TODO(mpcomplete): consider clamping the number of suggestions to
       // AutocompleteProvider::kMaxMatches.
       for (size_t i = 0; i < suggestions.suggestions.size(); ++i) {
-        const ExtensionOmniboxSuggestion& suggestion =
+        const extensions::ExtensionOmniboxSuggestion& suggestion =
             suggestions.suggestions[i];
         // We want to order these suggestions in descending order, so start with
         // the relevance of the first result (added synchronously in Start()),
         // and subtract 1 for each subsequent suggestion from the extension.
         // We know that |complete| is true, because we wouldn't get results from
         // the extension unless the full keyword had been typed.
         int first_relevance = CalculateRelevance(input.type(), true, true,
             input.prefer_keyword(), input.allow_exact_keyword_match());
         extension_suggest_matches_.push_back(CreateAutocompleteMatch(
             model, keyword, input, keyword.length(),
@@ skipping 27 matching lines @@
   DCHECK(service);
   service->Load();
   return service;
 }
 
 void KeywordProvider::EnterExtensionKeywordMode(
     const std::string& extension_id) {
   DCHECK(current_keyword_extension_id_.empty());
   current_keyword_extension_id_ = extension_id;
 
-  ExtensionOmniboxEventRouter::OnInputStarted(
+  extensions::ExtensionOmniboxEventRouter::OnInputStarted(
       profile_, current_keyword_extension_id_);
 }
 
 void KeywordProvider::MaybeEndExtensionKeywordMode() {
   if (!current_keyword_extension_id_.empty()) {
-    ExtensionOmniboxEventRouter::OnInputCancelled(
+    extensions::ExtensionOmniboxEventRouter::OnInputCancelled(
         profile_, current_keyword_extension_id_);
 
     current_keyword_extension_id_.clear();
   }
 }