Move PageTransition from //content/public/common to //ui/base

chrome/browser/ui/omnibox/omnibox_edit_model.cc

 // Copyright 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/ui/omnibox/omnibox_edit_model.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/auto_reset.h"
@@ skipping 101 matching lines @@
 // between focusing and opening an omnibox match.
 const char kFocusToOpenTimeHistogram[] = "Omnibox.FocusToOpenTimeAnyPopupState";
 
 // Split the percentage match histograms into buckets based on the width of the
 // omnibox.
 const int kPercentageMatchHistogramWidthBuckets[] = { 400, 700, 1200 };
 
 void RecordPercentageMatchHistogram(const base::string16& old_text,
                                     const base::string16& new_text,
                                     bool url_replacement_active,
-                                    content::PageTransition transition,
+                                    ui::PageTransition transition,
                                     int omnibox_width) {
   size_t avg_length = (old_text.length() + new_text.length()) / 2;
 
   int percent = 0;
   if (!old_text.empty() && !new_text.empty()) {
     size_t shorter_length = std::min(old_text.length(), new_text.length());
     base::string16::const_iterator end(old_text.begin() + shorter_length);
     base::string16::const_iterator mismatch(
         std::mismatch(old_text.begin(), end, new_text.begin()).first);
     size_t matching_characters = mismatch - old_text.begin();
     percent = static_cast<float>(matching_characters) / avg_length * 100;
   }
 
   std::string histogram_name;
   if (url_replacement_active) {
-    if (transition == content::PAGE_TRANSITION_TYPED) {
+    if (transition == ui::PAGE_TRANSITION_TYPED) {
       histogram_name = "InstantExtended.PercentageMatchV2_QuerytoURL";
       UMA_HISTOGRAM_PERCENTAGE(histogram_name, percent);
     } else {
       histogram_name = "InstantExtended.PercentageMatchV2_QuerytoQuery";
       UMA_HISTOGRAM_PERCENTAGE(histogram_name, percent);
     }
   } else {
-    if (transition == content::PAGE_TRANSITION_TYPED) {
+    if (transition == ui::PAGE_TRANSITION_TYPED) {
       histogram_name = "InstantExtended.PercentageMatchV2_URLtoURL";
       UMA_HISTOGRAM_PERCENTAGE(histogram_name, percent);
     } else {
       histogram_name = "InstantExtended.PercentageMatchV2_URLtoQuery";
       UMA_HISTOGRAM_PERCENTAGE(histogram_name, percent);
     }
   }
 
   std::string suffix = "large";
   for (size_t i = 0; i < arraysize(kPercentageMatchHistogramWidthBuckets);
@@ skipping 505 matching lines @@
     if (url_match.destination_url.is_valid()) {
       // We have a valid URL, we use this newly generated AutocompleteMatch.
       match = url_match;
       alternate_nav_url = GURL();
     }
   }
 
   if (!match.destination_url.is_valid())
     return;
 
-  if ((match.transition == content::PAGE_TRANSITION_TYPED) &&
+  if ((match.transition == ui::PAGE_TRANSITION_TYPED) &&
       (match.destination_url == PermanentURL())) {
     // When the user hit enter on the existing permanent URL, treat it like a
     // reload for scoring purposes.  We could detect this by just checking
     // user_input_in_progress_, but it seems better to treat "edits" that end
     // up leaving the URL unchanged (e.g. deleting the last character and then
     // retyping it) as reloads too.  We exclude non-TYPED transitions because if
     // the transition is GENERATED, the user input something that looked
     // different from the current URL, even if it wound up at the same place
     // (e.g. manually retyping the same search query), and it seems wrong to
     // treat this as a reload.
-    match.transition = content::PAGE_TRANSITION_RELOAD;
+    match.transition = ui::PAGE_TRANSITION_RELOAD;
   } else if (for_drop || ((paste_state_ != NONE) &&
                           match.is_history_what_you_typed_match)) {
     // When the user pasted in a URL and hit enter, score it like a link click
     // rather than a normal typed URL, so it doesn't get inline autocompleted
     // as aggressively later.
-    match.transition = content::PAGE_TRANSITION_LINK;
+    match.transition = ui::PAGE_TRANSITION_LINK;
   }
 
   TemplateURLService* service =
       TemplateURLServiceFactory::GetForProfile(profile_);
   const TemplateURL* template_url = match.GetTemplateURL(service, false);
   if (template_url && template_url->url_ref().HasGoogleBaseURLs(
           UIThreadSearchTermsData(profile_))) {
     GoogleURLTracker* tracker =
         GoogleURLTrackerFactory::GetForProfile(profile_);
     if (tracker)
@@ skipping 85 matching lines @@
       content::Details<OmniboxLog>(&log));
   LOCAL_HISTOGRAM_BOOLEAN("Omnibox.EventCount", true);
   DCHECK(!last_omnibox_focus_.is_null())
       << "An omnibox focus should have occurred before opening a match.";
   UMA_HISTOGRAM_TIMES(kFocusToOpenTimeHistogram, now - last_omnibox_focus_);
 
   TemplateURLService* service =
       TemplateURLServiceFactory::GetForProfile(profile_);
   TemplateURL* template_url = match.GetTemplateURL(service, false);
   if (template_url) {
-    if (match.transition == content::PAGE_TRANSITION_KEYWORD) {
+    if (match.transition == ui::PAGE_TRANSITION_KEYWORD) {
       // The user is using a non-substituting keyword or is explicitly in
       // keyword mode.
 
       // Don't increment usage count for extension keywords.
       if (delegate_->ProcessExtensionKeyword(template_url, match,
                                              disposition)) {
         observer->OnSuccessfulNavigation();
         if (disposition != NEW_BACKGROUND_TAB)
           view_->RevertAll();
         return;
       }
 
       content::RecordAction(base::UserMetricsAction("AcceptedKeyword"));
       TemplateURLServiceFactory::GetForProfile(profile_)->IncrementUsageCount(
           template_url);
     } else {
-      DCHECK_EQ(content::PAGE_TRANSITION_GENERATED, match.transition);
+      DCHECK_EQ(ui::PAGE_TRANSITION_GENERATED, match.transition);
       // NOTE: We purposefully don't increment the usage count of the default
       // search engine here like we do for explicit keywords above; see comments
       // in template_url.h.
     }
 
     UMA_HISTOGRAM_ENUMERATION(
         "Omnibox.SearchEngineType",
         TemplateURLPrepopulateData::GetEngineType(
             *template_url, UIThreadSearchTermsData(profile_)),
         SEARCH_ENGINE_MAX);
@@ skipping 18 matching lines @@
       IsSearchResultsPageFromDefaultSearchProvider(match.destination_url)) {
     content::RecordAction(
         base::UserMetricsAction("OmniboxDestinationURLIsSearchOnDSP"));
   }
 
   if (match.destination_url.is_valid()) {
     // This calls RevertAll again.
     base::AutoReset<bool> tmp(&in_revert_, true);
     controller_->OnAutocompleteAccept(
         match.destination_url, disposition,
-        content::PageTransitionFromInt(
-            match.transition | content::PAGE_TRANSITION_FROM_ADDRESS_BAR));
+        ui::PageTransitionFromInt(
+            match.transition | ui::PAGE_TRANSITION_FROM_ADDRESS_BAR));
     if (observer->load_state() != OmniboxNavigationObserver::LOAD_NOT_SEEN)
       ignore_result(observer.release());  // The observer will delete itself.
   }
 
   BookmarkModel* bookmark_model = BookmarkModelFactory::GetForProfile(profile_);
   if (bookmark_model && bookmark_model->IsBookmarked(match.destination_url))
     RecordBookmarkLaunch(NULL, BOOKMARK_LAUNCH_LOCATION_OMNIBOX);
 }
 
 bool OmniboxEditModel::AcceptKeyword(EnteredKeywordModeMethod entered_method) {
@@ skipping 469 matching lines @@
     // explicitly set up a match that will reload here.
 
     // It's important that we fetch the current visible URL to reload instead of
     // just getting a "search what you typed" URL from
     // SearchProvider::CreateSearchSuggestion(), since the user may be in a
     // non-default search mode such as image search.
     match->type = AutocompleteMatchType::SEARCH_WHAT_YOU_TYPED;
     match->provider = autocomplete_controller()->search_provider();
     match->destination_url =
         delegate_->GetNavigationController().GetVisibleEntry()->GetURL();
-    match->transition = content::PAGE_TRANSITION_RELOAD;
+    match->transition = ui::PAGE_TRANSITION_RELOAD;
   } else if (query_in_progress() ||
              (popup_model() && popup_model()->IsOpen())) {
     if (query_in_progress()) {
       // It's technically possible for |result| to be empty if no provider
       // returns a synchronous result but the query has not completed
       // synchronously; pratically, however, that should never actually happen.
       if (result().empty())
         return;
       // The user cannot have manually selected a match, or the query would have
       // stopped. So the default match must be the desired selection.
@@ skipping 122 matching lines @@
   // Update state and notify view if the omnibox has focus and the caret
   // visibility changed.
   const bool was_caret_visible = is_caret_visible();
   focus_state_ = state;
   if (focus_state_ != OMNIBOX_FOCUS_NONE &&
       is_caret_visible() != was_caret_visible)
     view_->ApplyCaretVisibility();
 
   delegate_->OnFocusChanged(focus_state_, reason);
 }