[sync] skeleton implementation of TypedURLSyncBridge

components/history/core/browser/history_backend.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 "components/history/core/browser/history_backend.h"
 
 #include <algorithm>
 #include <functional>
 #include <list>
 #include <map>
 #include <memory>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
+#include "base/debug/dump_without_crashing.h"
+#include "base/feature_list.h"
 #include "base/files/file_enumerator.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/rand_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "components/favicon_base/favicon_util.h"
 #include "components/favicon_base/select_favicon_frames.h"
 #include "components/history/core/browser/download_constants.h"
 #include "components/history/core/browser/download_row.h"
 #include "components/history/core/browser/history_backend_client.h"
 #include "components/history/core/browser/history_backend_observer.h"
 #include "components/history/core/browser/history_constants.h"
 #include "components/history/core/browser/history_database.h"
 #include "components/history/core/browser/history_database_params.h"
 #include "components/history/core/browser/history_db_task.h"
 #include "components/history/core/browser/in_memory_history_backend.h"
 #include "components/history/core/browser/keyword_search_term.h"
 #include "components/history/core/browser/page_usage_data.h"
+#include "components/history/core/browser/typed_url_sync_bridge.h"
 #include "components/history/core/browser/typed_url_syncable_service.h"
 #include "components/history/core/browser/url_utils.h"
+#include "components/sync/driver/sync_driver_switches.h"
 #include "net/base/registry_controlled_domains/registry_controlled_domain.h"
 #include "sql/error_delegate_util.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/png_codec.h"
 #include "url/gurl.h"
 #include "url/url_constants.h"
 
 #if defined(OS_IOS)
 #include "base/ios/scoped_critical_action.h"
 #endif
 
+using base::debug::DumpWithoutCrashing;
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
+using syncer::ModelTypeChangeProcessor;
 
 /* The HistoryBackend consists of two components:
 
     HistoryDatabase (stores past 3 months of history)
       URLDatabase (stores a list of URLs)
       DownloadDatabase (stores a list of downloads)
       VisitDatabase (stores a list of visits for the URLs)
       VisitSegmentDatabase (stores groups of URLs for the most visited view).
 
     ExpireHistoryBackend (manages deleting things older than 3 months)
@@ skipping 136 matching lines @@
     bool force_fail,
     const HistoryDatabaseParams& history_database_params) {
   // HistoryBackend is created on the UI thread by HistoryService, then the
   // HistoryBackend::Init() method is called on the DB thread. Create the
   // base::SupportsUserData on the DB thread since it is not thread-safe.
   supports_user_data_helper_.reset(new HistoryBackendHelper);
 
   if (!force_fail)
     InitImpl(history_database_params);
   delegate_->DBLoaded();
-  typed_url_syncable_service_.reset(new TypedUrlSyncableService(this));
+  if (base::FeatureList::IsEnabled(switches::kSyncUSSTypedURL)) {
+    typed_url_sync_bridge_ = base::MakeUnique<TypedURLSyncBridge>(
+        this,
+        base::BindRepeating(
+            &ModelTypeChangeProcessor::Create,
+            base::BindRepeating(base::IgnoreResult(&DumpWithoutCrashing))));

[skym, 2017/03/07 18:08:04]

Ugh. Okay, this is kind of a land mine that we're setting ourselves up for.
Typically we want to report 1% of errors on canary/dev. But this reports 100% on
all channels. We ultimately need to thread channel information into here similar
to what Max proposed in https://codereview.chromium.org/2647113002/. I really
wish we had a more convenient way of solving this.

Can you at least throw a big TODO in here explaining that this is mainly for
initial testing and needs to be fixed before launch?

[Gang Wu, 2017/03/31 19:35:58]

Done.

+  } else {
+    typed_url_syncable_service_ =
+        base::MakeUnique<TypedUrlSyncableService>(this);
+  }
+
   memory_pressure_listener_.reset(new base::MemoryPressureListener(
       base::Bind(&HistoryBackend::OnMemoryPressure, base::Unretained(this))));
 }
 
 void HistoryBackend::SetOnBackendDestroyTask(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     const base::Closure& task) {
   if (!backend_destroy_task_.is_null())
     DLOG(WARNING) << "Setting more than one destroy task, overriding";
   backend_destroy_task_runner_ = std::move(task_runner);
@@ skipping 799 matching lines @@
   result->success = db_ && db_->GetRowForURL(url, &result->row);
   // Optionally query the visits.
   if (result->success && want_visits)
     db_->GetVisitsForURL(result->row.id(), &result->visits);
 }
 
 TypedUrlSyncableService* HistoryBackend::GetTypedUrlSyncableService() const {
   return typed_url_syncable_service_.get();
 }
 
+TypedURLSyncBridge* HistoryBackend::GetTypedURLSyncBridge() const {
+  return typed_url_sync_bridge_.get();
+}
+
 // Statistics ------------------------------------------------------------------
 
 HistoryCountResult HistoryBackend::GetHistoryCount(const Time& begin_time,
                                                    const Time& end_time) {
   HistoryCountResult result;
   result.count = 0;
   result.success =
       db_ && db_->GetHistoryCount(begin_time, end_time, &result.count);
   return result;
 }
@@ skipping 1557 matching lines @@
   // transaction is currently open.
   db_->CommitTransaction();
   db_->Vacuum();
   db_->BeginTransaction();
   db_->GetStartDate(&first_recorded_time_);
 
   return true;
 }
 
 }  // namespace history