Removing deprecated ios/web/user_metrics.cc and references to it.

ios/chrome/browser/browsing_data/ios_chrome_browsing_data_remover.mm

 // Copyright 2015 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 "ios/chrome/browser/browsing_data/ios_chrome_browsing_data_remover.h"
 
 #include <map>
 #include <set>
 #include <string>
 
@@ skipping 17 matching lines @@
 #include "ios/chrome/browser/browser_state/chrome_browser_state.h"
 #include "ios/chrome/browser/history/history_service_factory.h"
 #include "ios/chrome/browser/history/web_history_service_factory.h"
 #include "ios/chrome/browser/ios_chrome_io_thread.h"
 #include "ios/chrome/browser/passwords/ios_chrome_password_store_factory.h"
 #include "ios/chrome/browser/search_engines/template_url_service_factory.h"
 #include "ios/chrome/browser/sessions/ios_chrome_tab_restore_service_factory.h"
 #include "ios/chrome/browser/web_data_service_factory.h"
 #include "ios/net/http_cache_helper.h"
 #include "ios/public/provider/chrome/browser/chrome_browser_provider.h"
-#include "ios/web/public/user_metrics.h"
 #include "ios/web/public/web_thread.h"
 #include "net/base/net_errors.h"
 #include "net/cookies/cookie_store.h"
 #include "net/http/transport_security_state.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/channel_id_store.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using base::UserMetricsAction;
@@ skipping 37 matching lines @@
     : removal_begin(removal_begin), removal_mask(removal_mask) {}
 
 IOSChromeBrowsingDataRemover::NotificationDetails::~NotificationDetails() {}
 
 // Static.
 IOSChromeBrowsingDataRemover* IOSChromeBrowsingDataRemover::CreateForPeriod(
     ios::ChromeBrowserState* browser_state,
     TimePeriod period) {
   switch (period) {
     case EVERYTHING:
-      web::RecordAction(UserMetricsAction("ClearBrowsingData_Everything"));
+      base::RecordAction(UserMetricsAction("ClearBrowsingData_Everything"));
       break;
   }
   return new IOSChromeBrowsingDataRemover(
       browser_state,
       IOSChromeBrowsingDataRemover::CalculateBeginDeleteTime(period),
       base::Time::Max());
 }
 
 IOSChromeBrowsingDataRemover::IOSChromeBrowsingDataRemover(
     ios::ChromeBrowserState* browser_state,
@@ skipping 28 matching lines @@
 
 void IOSChromeBrowsingDataRemover::RemoveImpl(int remove_mask) {
   DCHECK_CURRENTLY_ON(WebThread::UI);
   set_removing(true);
   remove_mask_ = remove_mask;
 
   // On other platforms, it is possible to specify different types of origins
   // to clear data for (e.g., unprotected web vs. extensions). On iOS, this
   // mask is always implicitly the unprotected web, which is the only type that
   // is relevant. This metric is left here for historical consistency.
-  web::RecordAction(
+  base::RecordAction(
       UserMetricsAction("ClearBrowsingData_MaskContainsUnprotectedWeb"));
 
   if (remove_mask & REMOVE_HISTORY) {
     history::HistoryService* history_service =
         ios::HistoryServiceFactory::GetForBrowserState(
             browser_state_, ServiceAccessType::EXPLICIT_ACCESS);
     if (history_service) {
       std::set<GURL> restrict_urls;
-      web::RecordAction(UserMetricsAction("ClearBrowsingData_History"));
+      base::RecordAction(UserMetricsAction("ClearBrowsingData_History"));
       waiting_for_clear_history_ = true;
 
       history_service->ExpireLocalAndRemoteHistoryBetween(
           ios::WebHistoryServiceFactory::GetForBrowserState(browser_state_),
           restrict_urls, delete_begin_, delete_end_,
           base::Bind(&IOSChromeBrowsingDataRemover::OnHistoryDeletionDone,
                      base::Unretained(this)),
           &history_task_tracker_);
     }
 
@@ skipping 61 matching lines @@
 
       autofill::PersonalDataManager* data_manager =
           PersonalDataManagerFactory::GetForBrowserState(browser_state_);
       if (data_manager)
         data_manager->Refresh();
     }
 
   }
 
   if (remove_mask & REMOVE_COOKIES) {
-    web::RecordAction(UserMetricsAction("ClearBrowsingData_Cookies"));
+    base::RecordAction(UserMetricsAction("ClearBrowsingData_Cookies"));
 
     ++waiting_for_clear_cookies_count_;
     WebThread::PostTask(
         WebThread::IO, FROM_HERE,
         base::Bind(&IOSChromeBrowsingDataRemover::ClearCookiesOnIOThread,
                    base::Unretained(this), main_context_getter_));
 
     // TODO(mkwst): If we're not removing passwords, then clear the 'zero-click'
     // flag for all credentials in the password store.
   }
 
   if (remove_mask & REMOVE_CHANNEL_IDS) {
-    web::RecordAction(UserMetricsAction("ClearBrowsingData_ChannelIDs"));
+    base::RecordAction(UserMetricsAction("ClearBrowsingData_ChannelIDs"));
     if (main_context_getter_) {
       waiting_for_clear_channel_ids_ = true;
       WebThread::PostTask(
           WebThread::IO, FROM_HERE,
           base::Bind(&IOSChromeBrowsingDataRemover::ClearChannelIDsOnIOThread,
                      base::Unretained(this), main_context_getter_));
     }
   }
 
   if (remove_mask & REMOVE_PASSWORDS) {
-    web::RecordAction(UserMetricsAction("ClearBrowsingData_Passwords"));
+    base::RecordAction(UserMetricsAction("ClearBrowsingData_Passwords"));
     password_manager::PasswordStore* password_store =
         IOSChromePasswordStoreFactory::GetForBrowserState(
             browser_state_, ServiceAccessType::EXPLICIT_ACCESS)
             .get();
 
     if (password_store) {
       waiting_for_clear_passwords_ = true;
       password_store->RemoveLoginsCreatedBetween(
           delete_begin_, delete_end_,
           base::Bind(&IOSChromeBrowsingDataRemover::OnClearedPasswords,
                      base::Unretained(this)));
     }
   }
 
   if (remove_mask & REMOVE_FORM_DATA) {
-    web::RecordAction(UserMetricsAction("ClearBrowsingData_Autofill"));
+    base::RecordAction(UserMetricsAction("ClearBrowsingData_Autofill"));
     scoped_refptr<autofill::AutofillWebDataService> web_data_service =
         ios::WebDataServiceFactory::GetAutofillWebDataForBrowserState(
             browser_state_, ServiceAccessType::EXPLICIT_ACCESS);
 
     if (web_data_service.get()) {
       waiting_for_clear_form_ = true;
       web_data_service->RemoveFormElementsAddedBetween(delete_begin_,
                                                        delete_end_);
       web_data_service->RemoveAutofillDataModifiedBetween(delete_begin_,
                                                           delete_end_);
       // The above calls are done on the UI thread but do their work on the DB
       // thread. So wait for it.
       WebThread::PostTaskAndReply(
           WebThread::DB, FROM_HERE, base::Bind(&base::DoNothing),
           base::Bind(&IOSChromeBrowsingDataRemover::OnClearedFormData,
                      base::Unretained(this)));
 
       autofill::PersonalDataManager* data_manager =
           PersonalDataManagerFactory::GetForBrowserState(browser_state_);
       if (data_manager)
         data_manager->Refresh();
     }
   }
 
   if (remove_mask & REMOVE_CACHE) {
-    web::RecordAction(UserMetricsAction("ClearBrowsingData_Cache"));
+    base::RecordAction(UserMetricsAction("ClearBrowsingData_Cache"));
 
     waiting_for_clear_cache_ = true;
     DCHECK(delete_begin_.is_null()) << "Partial clearing not supported";
     ClearHttpCache(browser_state_->GetRequestContext(),
                    WebThread::GetTaskRunnerForThread(WebThread::IO),
                    base::Bind(&IOSChromeBrowsingDataRemover::OnClearedCache,
                               base::Unretained(this)));
   }
 
   // Remove omnibox zero-suggest cache results.
@@ skipping 193 matching lines @@
   waiting_for_clear_autofill_origin_urls_ = false;
   NotifyAndDeleteIfDone();
 }
 
 // static
 IOSChromeBrowsingDataRemover::CallbackSubscription
 IOSChromeBrowsingDataRemover::RegisterOnBrowsingDataRemovedCallback(
     const IOSChromeBrowsingDataRemover::Callback& callback) {
   return GetOnBrowsingDataRemovedCallbacks()->Add(callback);
 }