Use mojo for WebappRegistry.

chrome/browser/browsing_data/browsing_data_remover.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/browsing_data/browsing_data_remover.h"
 
 #include <map>
 #include <set>
 #include <string>
 
@@ skipping 64 matching lines @@
 #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"
 #include "storage/browser/quota/special_storage_policy.h"
 #include "url/origin.h"
 
 #if BUILDFLAG(ANDROID_JAVA_UI)
 #include "chrome/browser/android/offline_pages/offline_page_model_factory.h"
-#include "chrome/browser/android/webapps/webapp_registry.h"
 #include "chrome/browser/precache/precache_manager_factory.h"
 #include "components/offline_pages/offline_page_feature.h"
 #include "components/offline_pages/offline_page_model.h"
 #include "components/precache/content/precache_manager.h"
+#include "content/public/browser/android/java_interfaces.h"
+#include "services/shell/public/cpp/interface_provider.h"
 #endif
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chromeos/attestation/attestation_constants.h"
 #include "chromeos/cryptohome/cryptohome_parameters.h"
 #include "chromeos/dbus/cryptohome_client.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "components/user_manager/user.h"
 #endif
@@ skipping 140 matching lines @@
     const base::Closure& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   net::ChannelIDService* channel_id_service =
       rq_context->GetURLRequestContext()->channel_id_service();
   channel_id_service->GetChannelIDStore()->DeleteForDomainsCreatedBetween(
       domain_predicate, delete_begin, delete_end,
       base::Bind(&OnClearedChannelIDsOnIOThread,
                  base::RetainedRef(std::move(rq_context)), callback));
 }
 
+#if BUILDFLAG(ANDROID_JAVA_UI)
+mojom::WebappRegistryPtr GetDefaultWebappRegistryPtr() {
+  mojom::WebappRegistryPtr webapp_registry;
+  content::GetGlobalJavaInterfaces()->GetInterface(&webapp_registry);
+  return webapp_registry;
+}
+#endif
+
 }  // namespace
 
 BrowsingDataRemover::CompletionInhibitor*
     BrowsingDataRemover::completion_inhibitor_ = nullptr;
 
 bool BrowsingDataRemover::TimeRange::operator==(
     const BrowsingDataRemover::TimeRange& other) const {
   return begin == other.begin && end == other.end;
 }
 
@@ skipping 25 matching lines @@
   return TimeRange(CalculateBeginDeleteTime(period), base::Time::Max());
 }
 
 BrowsingDataRemover::BrowsingDataRemover(
     content::BrowserContext* browser_context)
     : profile_(Profile::FromBrowserContext(browser_context)),
       is_removing_(false),
       remove_mask_(-1),
       origin_type_mask_(-1),
 #if BUILDFLAG(ANDROID_JAVA_UI)
-      webapp_registry_(new WebappRegistry()),
+      webapp_registry_(GetDefaultWebappRegistryPtr()),
 #endif
       weak_ptr_factory_(this) {
   DCHECK(browser_context);
 }
 
 BrowsingDataRemover::~BrowsingDataRemover() {
   // If we are still removing data, notify observers so they can remove
   // themselves from the observer list.
   // TODO(bauerb): If it becomes a problem that browsing data might not actually
   // be fully cleared when an observer is notified, add a success flag.
@@ skipping 664 matching lines @@
           base::Bind(&BrowsingDataRemover::OnClearedDomainReliabilityMonitor,
                      weak_ptr_factory_.GetWeakPtr()));
     }
   }
 
 #if BUILDFLAG(ANDROID_JAVA_UI)
   if (remove_mask & REMOVE_WEBAPP_DATA) {
     // Clear all data associated with registered webapps. The webapp_registry
     // makes a JNI call into a Java-side AsyncTask, so don't wait for the reply.
     waiting_for_clear_webapp_data_ = true;
-    webapp_registry_->UnregisterWebapps(
+    webapp_registry_->UnregisterAllWebapps(
         base::Bind(&BrowsingDataRemover::OnClearedWebappData,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   // For now we're considering offline pages as cache, so if we're removing
   // cache we should remove offline pages as well.
   if ((remove_mask & REMOVE_CACHE) && offline_pages::IsOfflinePagesEnabled()) {
     waiting_for_clear_offline_page_data_ = true;
     offline_pages::OfflinePageModelFactory::GetForBrowserContext(profile_)
         ->DeletePagesByURLPredicate(
@@ skipping 30 matching lines @@
   observer_list_.RemoveObserver(observer);
 }
 
 void BrowsingDataRemover::OverrideStoragePartitionForTesting(
     content::StoragePartition* storage_partition) {
   storage_partition_for_testing_ = storage_partition;
 }
 
 #if BUILDFLAG(ANDROID_JAVA_UI)
 void BrowsingDataRemover::OverrideWebappRegistryForTesting(
-    std::unique_ptr<WebappRegistry> webapp_registry) {
-  webapp_registry_.reset(webapp_registry.release());
+    mojom::WebappRegistryPtr webapp_registry) {
+  webapp_registry_ = std::move(webapp_registry);
 }
 #endif
 
 const base::Time& BrowsingDataRemover::GetLastUsedBeginTime() {
   return delete_begin_;
 }
 
 const base::Time& BrowsingDataRemover::GetLastUsedEndTime() {
   return delete_end_;
 }
@@ skipping 248 matching lines @@
   waiting_for_clear_offline_page_data_ = false;
   NotifyIfDone();
 }
 #endif
 
 void BrowsingDataRemover::OnClearedDomainReliabilityMonitor() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   waiting_for_clear_domain_reliability_monitor_ = false;
   NotifyIfDone();
 }