Enterprise policy to prevent queries to the Quirks Server

components/quirks/quirks_manager.cc

 // Copyright 2016 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/quirks/quirks_manager.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
@@ skipping 25 matching lines @@
 // Check if file exists, VLOG results.
 bool CheckAndLogFile(const base::FilePath& path) {
   const bool exists = base::PathExists(path);
   VLOG(1) << (exists ? "File" : "No File") << " found at " << path.value();
   // TODO(glevin): If file exists, do we want to implement a hash to verify that
   // the file hasn't been corrupted or tampered with?
   return exists;
 }
 
 base::FilePath CheckForIccFile(base::FilePath built_in_path,
-                               base::FilePath download_path) {
+                               base::FilePath download_path,
+                               bool quirks_enabled) {
   // First, look for icc file in old read-only location.  If there, we don't use
   // the Quirks server.
   // TODO(glevin): Awaiting final decision on how to handle old read-only files.
   if (CheckAndLogFile(built_in_path))
     return built_in_path;
 
   // If experimental Quirks flag isn't set, no other icc file is available.
-  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableQuirksClient)) {
+  if (!quirks_enabled) {
     VLOG(1) << "Quirks Client disabled, no built-in icc file available.";
     return base::FilePath();
   }
 
   // Check if QuirksClient has already downloaded icc file from server.
   if (CheckAndLogFile(download_path))
     return download_path;
 
   return base::FilePath();
 }
@@ skipping 53 matching lines @@
 void QuirksManager::RegisterPrefs(PrefRegistrySimple* registry) {
   registry->RegisterDictionaryPref(prefs::kQuirksClientLastServerCheck);
 }
 
 // Delay downloads until after login, to ensure that device policy has been set.
 void QuirksManager::OnLoginCompleted() {
   if (!waiting_for_login_)
     return;
 
   waiting_for_login_ = false;
+  if (!QuirksEnabled()) {
+    VLOG(1) << "Quirks Client disabled by device policy.";
+    return;
+  }
+
   for (const scoped_ptr<QuirksClient>& client : clients_)
     client->StartDownload();
 }
 
 void QuirksManager::RequestIccProfilePath(
     int64_t product_id,
     const RequestFinishedCallback& on_request_finished) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   std::string name = IdToFileName(product_id);
   base::PostTaskAndReplyWithResult(
       blocking_pool_.get(), FROM_HERE,
       base::Bind(&CheckForIccFile,
                  delegate_->GetBuiltInDisplayProfileDirectory().Append(name),
-                 delegate_->GetDownloadDisplayProfileDirectory().Append(name)),
+                 delegate_->GetDownloadDisplayProfileDirectory().Append(name),
+                 QuirksEnabled()),
       base::Bind(&QuirksManager::OnIccFilePathRequestCompleted,
                  weak_ptr_factory_.GetWeakPtr(), product_id,
                  on_request_finished));
 }
 
 void QuirksManager::ClientFinished(QuirksClient* client) {
   DCHECK(thread_checker_.CalledOnValidThread());
   SetLastServerCheck(client->product_id(), base::Time::Now());
   auto it = std::find_if(clients_.begin(), clients_.end(),
                          [client](const scoped_ptr<QuirksClient>& c) {
@@ skipping 12 matching lines @@
   return net::URLFetcher::Create(url, net::URLFetcher::GET, delegate);
 }
 
 void QuirksManager::OnIccFilePathRequestCompleted(
     int64_t product_id,
     const RequestFinishedCallback& on_request_finished,
     base::FilePath path) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // If we found a file or client is disabled, inform requester.
-  if (!path.empty() ||
-      !base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kEnableQuirksClient)) {
+  if (!path.empty() || !QuirksEnabled()) {
     on_request_finished.Run(path, false);
     // TODO(glevin): If Quirks files are ever modified on the server, we'll need
     // to modify this logic to check for updates. See crbug.com/595024.
     return;
   }
 
   double last_check = 0.0;
   local_state_->GetDictionary(prefs::kQuirksClientLastServerCheck)
       ->GetDouble(IdToHexString(product_id), &last_check);
 
@@ skipping 51 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   QuirksClient* client =
       new QuirksClient(product_id, on_request_finished, this);
   clients_.insert(make_scoped_ptr(client));
   if (!waiting_for_login_)
     client->StartDownload();
   else
     VLOG(2) << "Quirks Client created; waiting for login to begin download.";
 }
 
+bool QuirksManager::QuirksEnabled() {
+  return base::CommandLine::ForCurrentProcess()->HasSwitch(
+             switches::kEnableQuirksClient) &&
+         delegate_->DevicePolicyEnabled();
+}
+
 void QuirksManager::SetLastServerCheck(int64_t product_id,
                                        const base::Time& last_check) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DictionaryPrefUpdate dict(local_state_, prefs::kQuirksClientLastServerCheck);
   dict->SetDouble(IdToHexString(product_id), last_check.ToDoubleT());
 }
 
 }  // namespace quirks