[USS] Move GetAllNodes from backend to controller

components/browser_sync/browser/profile_sync_service.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/browser_sync/browser/profile_sync_service.h"
 
 #include <stddef.h>
 
 #include <cstddef>
 #include <map>
@@ skipping 43 matching lines @@
 #include "components/sync/core/shared_model_type_processor.h"
 #include "components/sync/core/shutdown_reason.h"
 #include "components/sync/core/sync_encryption_handler.h"
 #include "components/sync/device_info/device_info.h"
 #include "components/sync/device_info/device_info_service.h"
 #include "components/sync/device_info/device_info_sync_service.h"
 #include "components/sync/device_info/device_info_tracker.h"
 #include "components/sync/driver/backend_migrator.h"
 #include "components/sync/driver/change_processor.h"
 #include "components/sync/driver/data_type_controller.h"
+#include "components/sync/driver/directory_data_type_controller.h"
 #include "components/sync/driver/glue/chrome_report_unrecoverable_error.h"
 #include "components/sync/driver/glue/sync_backend_host.h"
 #include "components/sync/driver/glue/sync_backend_host_impl.h"
 #include "components/sync/driver/pref_names.h"
 #include "components/sync/driver/signin_manager_wrapper.h"
 #include "components/sync/driver/sync_api_component_factory.h"
 #include "components/sync/driver/sync_client.h"
 #include "components/sync/driver/sync_driver_switches.h"
 #include "components/sync/driver/sync_error_controller.h"
 #include "components/sync/driver/sync_stopped_reporter.h"
 #include "components/sync/driver/sync_type_preference_provider.h"
 #include "components/sync/driver/sync_util.h"
 #include "components/sync/driver/system_encryptor.h"
 #include "components/sync/driver/user_selectable_sync_type.h"
 #include "components/sync/engine/cycle/model_neutral_state.h"
 #include "components/sync/engine/cycle/type_debug_info_observer.h"
 #include "components/sync/engine/sync_string_conversions.h"
 #include "components/sync/js/js_event_details.h"
 #include "components/sync/protocol/sync.pb.h"
 #include "components/sync/syncable/directory.h"
+#include "components/sync/syncable/syncable_read_transaction.h"
 #include "components/sync_sessions/favicon_cache.h"
 #include "components/sync_sessions/session_data_type_controller.h"
 #include "components/sync_sessions/sessions_sync_manager.h"
 #include "components/sync_sessions/sync_sessions_client.h"
 #include "components/syncable_prefs/pref_service_syncable.h"
 #include "components/version_info/version_info_values.h"
 #include "net/cookies/cookie_monster.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/time_format.h"
@@ skipping 2098 matching lines @@
 
 namespace {
 
 class GetAllNodesRequestHelper
     : public base::RefCountedThreadSafe<GetAllNodesRequestHelper> {
  public:
   GetAllNodesRequestHelper(
       syncer::ModelTypeSet requested_types,
       const base::Callback<void(std::unique_ptr<base::ListValue>)>& callback);
 
   void OnReceivedNodesForTypes(

[maxbogue, 2016/08/25 23:38:59]

This should become OnReceivedNodesForType, since now we're only calling it with
one type at a time. Same signature change as in DTC:

void OnReceivedNodesForType(syncer::ModelType type,
std::unique_ptr<base::ListValue> node_list);

[Gang Wu, 2016/08/26 16:48:04]

Done.

       const std::vector<syncer::ModelType>& types,
       ScopedVector<base::ListValue> scoped_node_lists);
 
  private:
   friend class base::RefCountedThreadSafe<GetAllNodesRequestHelper>;
   virtual ~GetAllNodesRequestHelper();
 
   std::unique_ptr<base::ListValue> result_accumulator_;
 
   syncer::ModelTypeSet awaiting_types_;
@@ skipping 30 matching lines @@
   scoped_node_lists.release(&node_lists);
 
   for (size_t i = 0; i < node_lists.size() && i < types.size(); ++i) {
     const ModelType type = types[i];
     base::ListValue* node_list = node_lists[i];
 
     // Add these results to our list.
     std::unique_ptr<base::DictionaryValue> type_dict(
         new base::DictionaryValue());
     type_dict->SetString("type", ModelTypeToString(type));
     type_dict->Set("nodes", node_list);

[maxbogue, 2016/08/25 23:38:59]

Does this take ownership of the list pointer? Can you check and comment saying
so if it does? Otherwise we're just leaking it...

[Gang Wu, 2016/08/26 16:48:04]

Done.

     result_accumulator_->Append(std::move(type_dict));
 
     // Remember that this part of the request is satisfied.
     awaiting_types_.Remove(type);
   }
 
   if (awaiting_types_.Empty()) {
     callback_.Run(std::move(result_accumulator_));
     callback_.Reset();
   }
 }
 
 }  // namespace
 
 void ProfileSyncService::GetAllNodes(
     const base::Callback<void(std::unique_ptr<base::ListValue>)>& callback) {
   // TODO(stanisc): crbug.com/328606: Make this work for USS datatypes.
   ModelTypeSet all_types = GetRegisteredDataTypes();

[maxbogue, 2016/08/25 23:38:59]

Should this be using GetEnabledDataTypes()? It was filtered down in the backend
before, wasn't it? Though if it was, I'm not sure how the
GetAllNodesRequestHelper was finishing...

[Gang Wu, 2016/08/26 16:48:04]

I did not find GetEnabledDataTypes(), so I let DTC to filter disabled data type
by return empty list for disabled data type.
backend did the same thing, it use registrar to find which data type is
disabled, and sent empty list for it.
GetAllNodesRequestHelper will ignore empty list to display.

   all_types.PutAll(syncer::ControlTypes());
   scoped_refptr<GetAllNodesRequestHelper> helper =
       new GetAllNodesRequestHelper(all_types, callback);
 
   if (!backend_initialized_) {
     // If there's no backend available to fulfill the request, handle it here.
     ScopedVector<base::ListValue> empty_results;
     std::vector<ModelType> type_vector;
     for (ModelTypeSet::Iterator it = all_types.First(); it.Good(); it.Inc()) {
       type_vector.push_back(it.Get());
       empty_results.push_back(new base::ListValue());
     }
     helper->OnReceivedNodesForTypes(type_vector, std::move(empty_results));
   } else {
-    backend_->GetAllNodesForTypes(
-        all_types,
+    GetAllNodesForTypes(
+        all_types, base::ThreadTaskRunnerHandle::Get(),
         base::Bind(&GetAllNodesRequestHelper::OnReceivedNodesForTypes, helper));
   }
 }
 
 bool ProfileSyncService::HasObserver(
     const sync_driver::SyncServiceObserver* observer) const {
   return observers_.HasObserver(observer);
 }
 
 base::WeakPtr<syncer::JsController> ProfileSyncService::GetJsController() {
@@ skipping 235 matching lines @@
   if (--outstanding_setup_in_progress_handles_ != 0)
     return;
 
   DCHECK(startup_controller_->IsSetupInProgress());
   startup_controller_->SetSetupInProgress(false);
 
   if (IsBackendInitialized())
     ReconfigureDatatypeManager();
   NotifyObservers();
 }
+
+void ProfileSyncService::GetAllNodesForTypes(
+    syncer::ModelTypeSet types,
+    scoped_refptr<base::SequencedTaskRunner> task_runner,
+    base::Callback<void(const std::vector<syncer::ModelType>& type,
+                        ScopedVector<base::ListValue>)> callback) {
+  std::vector<syncer::ModelType> types_vector;
+  ScopedVector<base::ListValue> node_lists;
+
+  for (syncer::ModelTypeSet::Iterator it = types.First(); it.Good(); it.Inc()) {
+    DataTypeController::TypeMap::const_iterator iter =
+        data_type_controllers_.find(it.Get());
+    if (iter != data_type_controllers_.end()) {
+      iter->second->GetAllNodes(base::ThreadTaskRunnerHandle::Get(), callback);
+    } else {
+      // Control Types
+      types_vector.push_back(it.Get());
+      node_lists.push_back(sync_driver::DirectoryDataTypeController::
+                               GetAllNodesForTypeFromDirectory(
+                                   it.Get(), GetUserShare()->directory.get())
+                                   .release());
+    }
+  }
+
+  if (!types_vector.empty()) {
+    callback.Run(types_vector, std::move(node_lists));
+  }
+}