Wired preference that hides hosted documents for the directory view.

chrome/browser/chromeos/gdata/gdata_file_system.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_GDATA_GDATA_FILE_SYSTEM_H_
 #define CHROME_BROWSER_CHROMEOS_GDATA_GDATA_FILE_SYSTEM_H_
 #pragma once
 
 #include <sys/stat.h>
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop.h"
 #include "base/platform_file.h"
 #include "base/synchronization/lock.h"
 #include "chrome/browser/chromeos/gdata/gdata_files.h"
 #include "chrome/browser/chromeos/gdata/gdata_operation_registry.h"
 #include "chrome/browser/chromeos/gdata/gdata_params.h"
 #include "chrome/browser/chromeos/gdata/gdata_parser.h"
 #include "chrome/browser/chromeos/gdata/gdata_uploader.h"
+#include "chrome/browser/prefs/pref_set_observer.h"
 #include "chrome/browser/profiles/profile_keyed_service.h"
 #include "chrome/browser/profiles/profile_keyed_service_factory.h"
+#include "content/public/browser/notification_observer.h"
 
 namespace base {
 class WaitableEvent;
 }
 
 namespace gdata {
 
 class DocumentsServiceInterface;
 struct UploadFileInfo;
 
@@ skipping 349 matching lines @@
   // Pin or unpin file.
   virtual void SetPinState(const FilePath& file_path, bool to_pin,
                            const FileOperationCallback& callback) = 0;
 
   // Creates a new file from |entry| under |virtual_dir_path|. Stored its
   // content from |file_content_path| into the cache.
   virtual void AddUploadedFile(const FilePath& virtual_dir_path,
                                DocumentEntry* entry,
                                const FilePath& file_content_path,
                                FileOperationType cache_operation) = 0;
+
+  // Returns true if hosted documents should be hidden.
+  virtual bool hide_hosted_documents() = 0;

[achuithb, 2012/04/04 19:14:11]

Shouldn't this be HideHostedDocuments?

[zel, 2012/04/04 20:16:57]

it's a simple getter, unlike its setter method that does way more when we flip
that state

[achuithb, 2012/04/04 20:46:19]

I'm not sure what the rule is with getters when they are pure virtual, but this
is a nit anyway.

 };
 
 // The production implementation of GDataFileSystemInterface.
-class GDataFileSystem : public GDataFileSystemInterface {
+class GDataFileSystem : public GDataFileSystemInterface,
+                        public content::NotificationObserver {
  public:
   GDataFileSystem(Profile* profile,
                   DocumentsServiceInterface* documents_service);
   virtual ~GDataFileSystem();
 
   // Shuts down the file system on UI thread. All pending operations are
   // canceled. Most parts of shutdown happens here. The destructor is only
   // used to release objects on the IO thread.
   void ShutdownOnUIThread();
 
@@ skipping 56 matching lines @@
       CachedFileOrigin file_orign) const OVERRIDE;
   virtual void GetAvailableSpace(
       const GetAvailableSpaceCallback& callback) OVERRIDE;
   // Calls private Pin or Unpin methods with |callback|.
   virtual void SetPinState(const FilePath& file_path, bool pin,
                            const FileOperationCallback& callback) OVERRIDE;
   virtual void AddUploadedFile(const FilePath& virtual_dir_path,
                                DocumentEntry* entry,
                                const FilePath& file_content_path,
                                FileOperationType cache_operation) OVERRIDE;
+  virtual bool hide_hosted_documents() OVERRIDE;
+
+  // content::NotificationObserver implementation.
+  virtual void Observe(int type,
+                       const content::NotificationSource& source,
+                       const content::NotificationDetails& details) OVERRIDE;
 
  private:
   friend class GDataUploader;
   friend class GDataFileSystemTest;
   FRIEND_TEST_ALL_PREFIXES(GDataFileSystemTest,
                            FindFirstMissingParentDirectory);
   FRIEND_TEST_ALL_PREFIXES(GDataFileSystemTest,
                            GetGDataFileInfoFromPath);
   FRIEND_TEST_ALL_PREFIXES(GDataFileSystemTest,
                            GetFromCacheForPath);
@@ skipping 711 matching lines @@
   // Helper function used to perform file search on the calling thread of
   // FindFileByPath() request.
   void FindFileByPathOnCallingThread(const FilePath& search_file_path,
                                      const FindFileCallback& callback);
 
   void OnSetPinStateCompleted(const FileOperationCallback& callback,
                               base::PlatformFileError error,
                               const std::string& resource_id,
                               const std::string& md5);
 
+  // Changes state of hosted documents visibility, triggers directory refresh.
+  void SetHideHostedDocuments(bool hide);
+
+  // Initializes preference change observer.
+  void InitializePreferenceObserver();
+
   scoped_ptr<GDataRootDirectory> root_;
 
   // This guards regular states.
   base::Lock lock_;
 
   // The profile hosts the GDataFileSystem via GDataSystemService.
   Profile* profile_;
 
   // The document service for the GDataFileSystem.
   scoped_ptr<DocumentsServiceInterface> documents_service_;
 
   // Base path for GData cache, e.g. <user_profile_dir>/user/GCache/v1.
   FilePath gdata_cache_path_;
 
   // Paths for all subdirectories of GCache, one for each
   // GDataRootDirectory::CacheSubDirectoryType enum.
   std::vector<FilePath> cache_paths_;
 
   scoped_ptr<base::WaitableEvent> on_io_completed_;
 
   // True if cache initialization has started, is in progress or has completed,
   // we only want to initialize cache once.
   bool cache_initialization_started_;
 
   // Number of pending tasks on the blocking thread pool.
   int num_pending_tasks_;
   base::Lock num_pending_tasks_lock_;
 
+  // True if hosted documents should be hidden.
+  bool hide_hosted_docs_;
+
+  scoped_ptr<PrefSetObserver> pref_observer_;
+
   // WeakPtrFactory and WeakPtr bound to the UI thread.
   scoped_ptr<base::WeakPtrFactory<GDataFileSystem> > ui_weak_ptr_factory_;
   base::WeakPtr<GDataFileSystem> ui_weak_ptr_;
 
   // WeakPtrFactory bound to the IO thread. Created when needed.
   scoped_ptr<base::WeakPtrFactory<GDataFileSystem> > io_weak_ptr_factory_;
 
   ObserverList<Observer> observers_;
 };
 
 }  // namespace gdata
 
 #endif  // CHROME_BROWSER_CHROMEOS_GDATA_GDATA_FILE_SYSTEM_H_