1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
// Copyright 2014 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.
#ifndef COMPONENTS_DRIVE_DIRECTORY_LOADER_H_
#define COMPONENTS_DRIVE_DIRECTORY_LOADER_H_
#include <stdint.h>
#include <map>
#include <set>
#include <string>
#include <vector>
#include "base/callback.h"
#include "base/macros.h"
#include "base/memory/ref_counted.h"
#include "base/memory/scoped_ptr.h"
#include "base/observer_list.h"
#include "base/threading/thread_checker.h"
#include "components/drive/file_errors.h"
#include "components/drive/file_system_interface.h"
#include "google_apis/drive/drive_api_error_codes.h"
#include "google_apis/drive/drive_common_callbacks.h"
namespace base {
class SequencedTaskRunner;
} // namespace base
namespace google_apis {
class AboutResource;
} // namespace google_apis
namespace drive {
class EventLogger;
class JobScheduler;
class ResourceEntry;
namespace internal {
class AboutResourceLoader;
class ChangeList;
class ChangeListLoaderObserver;
class DirectoryFetchInfo;
class LoaderController;
class ResourceMetadata;
// DirectoryLoader is used to load directory contents.
class DirectoryLoader {
public:
DirectoryLoader(EventLogger* logger,
base::SequencedTaskRunner* blocking_task_runner,
ResourceMetadata* resource_metadata,
JobScheduler* scheduler,
AboutResourceLoader* about_resource_loader,
LoaderController* apply_task_controller);
~DirectoryLoader();
// Adds and removes the observer.
void AddObserver(ChangeListLoaderObserver* observer);
void RemoveObserver(ChangeListLoaderObserver* observer);
// Reads the directory contents.
// |entries_callback| can be null.
// |completion_callback| must not be null.
void ReadDirectory(const base::FilePath& directory_path,
const ReadDirectoryEntriesCallback& entries_callback,
const FileOperationCallback& completion_callback);
private:
class FeedFetcher;
struct ReadDirectoryCallbackState;
// Part of ReadDirectory().
void ReadDirectoryAfterGetEntry(
const base::FilePath& directory_path,
const ReadDirectoryEntriesCallback& entries_callback,
const FileOperationCallback& completion_callback,
bool should_try_loading_parent,
const ResourceEntry* entry,
FileError error);
void ReadDirectoryAfterLoadParent(
const base::FilePath& directory_path,
const ReadDirectoryEntriesCallback& entries_callback,
const FileOperationCallback& completion_callback,
FileError error);
void ReadDirectoryAfterGetAboutResource(
const std::string& local_id,
google_apis::DriveApiErrorCode status,
scoped_ptr<google_apis::AboutResource> about_resource);
void ReadDirectoryAfterCheckLocalState(
scoped_ptr<google_apis::AboutResource> about_resource,
const std::string& local_id,
const ResourceEntry* entry,
const int64_t* local_changestamp,
FileError error);
// Part of ReadDirectory().
// This function should be called when the directory load is complete.
// Flushes the callbacks waiting for the directory to be loaded.
void OnDirectoryLoadComplete(const std::string& local_id, FileError error);
void OnDirectoryLoadCompleteAfterRead(const std::string& local_id,
const ResourceEntryVector* entries,
FileError error);
// Sends |entries| to the callbacks.
void SendEntries(const std::string& local_id,
const ResourceEntryVector& entries);
// ================= Implementation for directory loading =================
// Loads the directory contents from server, and updates the local metadata.
// Runs |callback| when it is finished.
void LoadDirectoryFromServer(const DirectoryFetchInfo& directory_fetch_info);
// Part of LoadDirectoryFromServer() for a normal directory.
void LoadDirectoryFromServerAfterLoad(
const DirectoryFetchInfo& directory_fetch_info,
FeedFetcher* fetcher,
FileError error);
// Part of LoadDirectoryFromServer().
void LoadDirectoryFromServerAfterUpdateChangestamp(
const DirectoryFetchInfo& directory_fetch_info,
const base::FilePath* directory_path,
FileError error);
EventLogger* logger_; // Not owned.
scoped_refptr<base::SequencedTaskRunner> blocking_task_runner_;
ResourceMetadata* resource_metadata_; // Not owned.
JobScheduler* scheduler_; // Not owned.
AboutResourceLoader* about_resource_loader_; // Not owned.
LoaderController* loader_controller_; // Not owned.
base::ObserverList<ChangeListLoaderObserver> observers_;
typedef std::map<std::string, std::vector<ReadDirectoryCallbackState> >
LoadCallbackMap;
LoadCallbackMap pending_load_callback_;
// Set of the running feed fetcher for the fast fetch.
std::set<FeedFetcher*> fast_fetch_feed_fetcher_set_;
base::ThreadChecker thread_checker_;
// Note: This should remain the last member so it'll be destroyed and
// invalidate its weak pointers before any other members are destroyed.
base::WeakPtrFactory<DirectoryLoader> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(DirectoryLoader);
};
} // namespace internal
} // namespace drive
#endif // COMPONENTS_DRIVE_DIRECTORY_LOADER_H_
|
