Using separate directories based on LifetimeType.

components/offline_pages/offline_page_model.h

 // 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.
 
 #ifndef COMPONENTS_OFFLINE_PAGES_OFFLINE_PAGE_MODEL_H_
 #define COMPONENTS_OFFLINE_PAGES_OFFLINE_PAGE_MODEL_H_
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <set>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/supports_user_data.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "components/offline_pages/offline_page_archiver.h"
+#include "components/offline_pages/offline_page_client_policy.h"
 #include "components/offline_pages/offline_page_metadata_store.h"
 
 class GURL;
 namespace base {
 class SequencedTaskRunner;
 class Time;
 class TimeDelta;
 }
 
 namespace offline_pages {
@@ skipping 89 matching lines @@
 
   typedef std::vector<OfflinePageItem> GetAllPagesResult;
   typedef std::set<GURL> CheckPagesExistOfflineResult;
 
   typedef base::Callback<void(SavePageResult, int64_t)> SavePageCallback;
   typedef base::Callback<void(DeletePageResult)> DeletePageCallback;
   typedef base::Callback<void(const GetAllPagesResult&)> GetAllPagesCallback;
   typedef base::Callback<void(const CheckPagesExistOfflineResult&)>
       CheckPagesExistOfflineCallback;
   typedef base::Callback<void(bool)> HasPagesCallback;
+  typedef std::map<LifetimePolicy::LifetimeType,
+                   const base::FilePath&> ArchiveDirs;
 
   // Generates a new offline id
   static int64_t GenerateOfflineId();
 
   // Returns true if an offline copy can be saved for the given URL.
   static bool CanSavePage(const GURL& url);
 
   static base::TimeDelta GetFinalDeletionDelayForTesting();
 
   // All blocking calls/disk access will happen on the provided |task_runner|.
   OfflinePageModel(std::unique_ptr<OfflinePageMetadataStore> store,
-                   const base::FilePath& archives_dir,
+                   const ArchiveDirs& archive_dirs,
                    const scoped_refptr<base::SequencedTaskRunner>& task_runner);
   ~OfflinePageModel() override;
 
   void AddObserver(Observer* observer);
   void RemoveObserver(Observer* observer);
 
   // Attempts to save a page addressed by |url| offline. Requires that the model
   // is loaded.  Generates a new offline id and returns it.
   void SavePage(const GURL& url,
                 const ClientId& client_id,
@@ skipping 155 matching lines @@
   // Actually does the work of deleting, requires the model is loaded.
   void DoDeletePagesByOfflineId(const std::vector<int64_t>& offline_ids,
                                 const DeletePageCallback& callback);
 
   // Similar to DoDeletePagesByOfflineId, does actual work of deleting, and
   // requires that the model is loaded.
   void DoDeletePagesByURLPredicate(
       const base::Callback<bool(const GURL&)>& predicate,
       const DeletePageCallback& callback);
 
+  // Get the archive directory for the client id.
+  const base::FilePath& GetArchivePath(const ClientId& client_id);
+
   void RunWhenLoaded(const base::Closure& job);
 
   // Persistent store for offline page metadata.
   std::unique_ptr<OfflinePageMetadataStore> store_;
 
-  // Location where all of the archive files will be stored.
-  base::FilePath archives_dir_;
+  // Location where all of the archive files will be stored based on namespace.
+  ArchiveDirs archive_dirs_;
 
   // The observers.
   base::ObserverList<Observer> observers_;
 
   bool is_loaded_;
 
   // In memory copy of the offline page metadata, keyed by bookmark IDs.
   std::map<int64_t, OfflinePageItem> offline_pages_;
 
   scoped_refptr<base::SequencedTaskRunner> task_runner_;
 
   // Pending archivers owned by this model.
   PendingArchivers pending_archivers_;
 
   // Delayed tasks that should be invoked after the loading is done.
   std::vector<base::Closure> delayed_tasks_;
 
   base::WeakPtrFactory<OfflinePageModel> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(OfflinePageModel);
 };
 
 }  // namespace offline_pages
 
 #endif  // COMPONENTS_OFFLINE_PAGES_OFFLINE_PAGE_MODEL_H_