Wired preference that hides hosted documents for the directory view.

chrome/browser/chromeos/gdata/gdata_file_system.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 "chrome/browser/chromeos/gdata/gdata_file_system.h"
 
 #include <errno.h>
 
 #include <utility>
 
@@ skipping 11 matching lines @@
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/gdata/gdata_documents_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_download_observer.h"
 #include "chrome/browser/chromeos/gdata/gdata_sync_client.h"
 #include "chrome/browser/chromeos/gdata/gdata_system_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_upload_file_info.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_constants.h"
+#include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_paths_internal.h"
+#include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
+#include "content/public/browser/notification_details.h"
 #include "net/base/mime_util.h"
 #include "webkit/fileapi/file_system_file_util_proxy.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_util.h"
 
 using content::BrowserThread;
 
 namespace gdata {
 namespace {
 
@@ skipping 428 matching lines @@
 // GDataFileSystem class implementatsion.
 
 GDataFileSystem::GDataFileSystem(Profile* profile,
                                  DocumentsServiceInterface* documents_service)
     : profile_(profile),
       documents_service_(documents_service),
       on_io_completed_(new base::WaitableEvent(
           true /* manual reset */, false /* initially not signaled */)),
       cache_initialization_started_(false),
       num_pending_tasks_(0),
+      hide_hosted_docs_(false),
       ui_weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(
           new base::WeakPtrFactory<GDataFileSystem>(this))),
       ui_weak_ptr_(ui_weak_ptr_factory_->GetWeakPtr()) {
   // Should be created from the file browser extension API on UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 void GDataFileSystem::Initialize() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   FilePath cache_base_path;
   chrome::GetUserCacheDirectory(profile_->GetPath(), &cache_base_path);
   gdata_cache_path_ = cache_base_path.Append(chrome::kGDataCacheDirname);
   gdata_cache_path_ = gdata_cache_path_.Append(kGDataCacheVersionDir);
   // Insert into |cache_paths_| in order defined in enum CacheSubDirectoryType.
   cache_paths_.push_back(gdata_cache_path_.Append(kGDataCacheMetaDir));
   cache_paths_.push_back(gdata_cache_path_.Append(kGDataCachePinnedDir));
   cache_paths_.push_back(gdata_cache_path_.Append(kGDataCacheOutgoingDir));
   cache_paths_.push_back(gdata_cache_path_.Append(kGDataCachePersistentDir));
   cache_paths_.push_back(gdata_cache_path_.Append(kGDataCacheTmpDir));
   cache_paths_.push_back(gdata_cache_path_.Append(kGDataCacheTmpDownloadsDir));
   cache_paths_.push_back(gdata_cache_path_.Append(kGDataCacheTmpDocumentsDir));
 
   documents_service_->Initialize(profile_);
 
   root_.reset(new GDataRootDirectory(this));
   root_->set_file_name(kGDataRootDirectory);
+
+  PrefService* pref_service = profile_->GetPrefs();
+  hide_hosted_docs_ = pref_service->GetBoolean(prefs::kDisableGDataHostedFiles);
+
+  InitializePreferenceObserver();
 }
 
 GDataFileSystem::~GDataFileSystem() {
   // Should be deleted on IO thread by GDataSystemService.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   // io_weak_ptr_factory_ must be deleted on IO thread.
   io_weak_ptr_factory_.reset();
   // documents_service_ must be deleted on IO thread, as it also owns
   // WeakPtrFactory bound to IO thread.
@@ skipping 2157 matching lines @@
     resource_id = file->resource_id();
     md5 = file->file_md5();
     parent_dir->AddFile(new_file.release());
   }
   NotifyDirectoryChanged(virtual_dir_path);
 
   StoreToCache(resource_id, md5, file_content_path, cache_operation,
                CacheOperationCallback());
 }
 
+void GDataFileSystem::Observe(int type,
+                              const content::NotificationSource& source,
+                              const content::NotificationDetails& details) {
+  if (type == chrome::NOTIFICATION_PREF_CHANGED) {
+    PrefService* pref_service = profile_->GetPrefs();
+    std::string* pref_name = content::Details<std::string>(details).ptr();
+    if (*pref_name == prefs::kDisableGDataHostedFiles) {
+      SetHideHostedDocuments(
+          pref_service->GetBoolean(prefs::kDisableGDataHostedFiles));
+    } else if (*pref_name == prefs::kDisableGDataOverCellular) {
+      // TODO(satorux): Disable pinning over mobil connection.
+    } else if (*pref_name == prefs::kDisableGData) {
+      // TODO(satorux): Disable gdata.
+    }

[satorux1, 2012/04/04 21:23:16]

Please remove TODOs. My part won't need code in GDataFileSystem.

http://codereview.chromium.org/9968105/

[zel, 2012/04/04 22:14:18]

Done.

+  } else {
+    NOTREACHED();
+  }
+}
+
+bool GDataFileSystem::hide_hosted_documents() {
+  base::AutoLock lock(lock_);
+  return hide_hosted_docs_;
+}
+
+void GDataFileSystem::SetHideHostedDocuments(bool hide) {
+  FilePath root_path;
+  {
+    base::AutoLock lock(lock_);
+    if (hide == hide_hosted_docs_)
+      return;
+
+    hide_hosted_docs_ = hide;
+    root_path = root_->GetFilePath();
+  }
+
+  // Kick of directory refresh when this setting changes.
+  NotifyDirectoryChanged(root_path);
+}
 
 //===================== GDataFileSystem: Cache entry points ====================
 
 FilePath GDataFileSystem::GetCacheFilePath(
     const std::string& resource_id,
     const std::string& md5,
     GDataRootDirectory::CacheSubDirectoryType sub_dir_type,
     CachedFileOrigin file_origin) const {
   DCHECK(sub_dir_type != GDataRootDirectory::CACHE_TYPE_META);
 
@@ skipping 1067 matching lines @@
   const bool posted = BrowserThread::PostTaskAndReply(
       BrowserThread::FILE,
       from_here,
       base::Bind(&GDataFileSystem::RunTaskOnIOThreadPool,
                  base::Unretained(this),
                  request_task),
       reply_task);
   DCHECK(posted);
 }
 
+void GDataFileSystem::InitializePreferenceObserver() {
+  pref_observer_.reset(new PrefSetObserver(profile_->GetPrefs(), this));

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

pref_observer_ doesn't seem to do anything? What am I missing?

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

it does. it's a helper class for registering for monitoring changed in a
specific set of preferences

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

Ah, got it. It takes care of the NotificationRegistrar business, and forwards
Observe notifications.

[satorux1, 2012/04/04 21:47:11]

BTW, PrefChangeRegistar solves the same problem.

PrefSetObserver is implemented on top of PrefChangeRegistar, but it doesn't seem
to be adding values. I'd prefer PrefChangeRegistar in favor of less indirection.

[zel, 2012/04/04 22:14:18]

Done.

+  pref_observer_->AddPref(prefs::kDisableGDataHostedFiles);
+  pref_observer_->AddPref(prefs::kDisableGDataOverCellular);
+  pref_observer_->AddPref(prefs::kDisableGData);
+}
+
 }  // namespace gdata