Revert 67530 - Persist 'this device is not managed' information...

chrome/browser/policy/device_management_policy_cache.cc

 // Copyright (c) 2010 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/policy/device_management_policy_cache.h"
 
 #include <limits>
 #include <string>
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/task.h"
 #include "base/values.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/policy/proto/device_management_constants.h"
 #include "chrome/browser/policy/proto/device_management_local.pb.h"
 
 using google::protobuf::RepeatedField;
 using google::protobuf::RepeatedPtrField;
 
 namespace policy {
 
 // Saves policy information to a file.
 class PersistPolicyTask : public Task {
  public:
   PersistPolicyTask(const FilePath& path,
                     const em::DevicePolicyResponse* policy,
-                    const base::Time& timestamp,
-                    const bool is_device_unmanaged)
-      : path_(path),
-        policy_(policy),
-        timestamp_(timestamp),
-        is_device_unmanaged_(is_device_unmanaged) {}
+                    const base::Time& timestamp);
 
  private:
   // Task override.
   virtual void Run();
 
   const FilePath path_;
   scoped_ptr<const em::DevicePolicyResponse> policy_;
   const base::Time timestamp_;
-  const bool is_device_unmanaged_;
 };
 
+PersistPolicyTask::PersistPolicyTask(const FilePath& path,
+                                     const em::DevicePolicyResponse* policy,
+                                     const base::Time& timestamp)
+    : path_(path),
+      policy_(policy),
+      timestamp_(timestamp) {
+}
+
 void PersistPolicyTask::Run() {
   std::string data;
   em::CachedDevicePolicyResponse cached_policy;
-  if (policy_.get())
-    cached_policy.mutable_policy()->CopyFrom(*policy_);
-  if (is_device_unmanaged_)
-    cached_policy.set_unmanaged(true);
+  cached_policy.mutable_policy()->CopyFrom(*policy_);
   cached_policy.set_timestamp(timestamp_.ToInternalValue());
   if (!cached_policy.SerializeToString(&data)) {
     LOG(WARNING) << "Failed to serialize policy data";
     return;
   }
 
   int size = data.size();
   if (file_util::WriteFile(path_, data.c_str(), size) != size) {
     LOG(WARNING) << "Failed to write " << path_.value();
     return;
   }
 }
 
 DeviceManagementPolicyCache::DeviceManagementPolicyCache(
     const FilePath& backing_file_path)
     : backing_file_path_(backing_file_path),
       policy_(new DictionaryValue),
-      fresh_policy_(false),
-      is_device_unmanaged_(false) {
+      fresh_policy_(false) {
 }
 
 void DeviceManagementPolicyCache::LoadPolicyFromFile() {
   if (!file_util::PathExists(backing_file_path_) || fresh_policy_)
     return;
 
   // Read the protobuf from the file.
   std::string data;
   if (!file_util::ReadFileToString(backing_file_path_, &data)) {
     LOG(WARNING) << "Failed to read policy data from "
                  << backing_file_path_.value();
     return;
   }
 
   em::CachedDevicePolicyResponse cached_policy;
   if (!cached_policy.ParseFromArray(data.c_str(), data.size())) {
     LOG(WARNING) << "Failed to parse policy data read from "
                  << backing_file_path_.value();
     return;
   }
 
   // Reject files that claim to be from the future.
   base::Time timestamp = base::Time::FromInternalValue(
       cached_policy.timestamp());
   if (timestamp > base::Time::NowFromSystemTime()) {
     LOG(WARNING) << "Rejected policy data from " << backing_file_path_.value()
                  << ", file is from the future.";
     return;
   }
-  is_device_unmanaged_ = cached_policy.unmanaged();
 
   // Decode and swap in the new policy information.
   scoped_ptr<DictionaryValue> value(DecodePolicy(cached_policy.policy()));
   {
     AutoLock lock(lock_);
     if (!fresh_policy_)
       policy_.reset(value.release());
     last_policy_refresh_time_ = timestamp;
   }
 }
 
 bool DeviceManagementPolicyCache::SetPolicy(
     const em::DevicePolicyResponse& policy) {
-  is_device_unmanaged_ = false;
   DictionaryValue* value = DeviceManagementPolicyCache::DecodePolicy(policy);
   const bool new_policy_differs = !(value->Equals(policy_.get()));
-  base::Time now(base::Time::NowFromSystemTime());
+  base::Time now(base::Time::Now());
   {
     AutoLock lock(lock_);
     policy_.reset(value);
     fresh_policy_ = true;
     last_policy_refresh_time_ = now;
   }
 
   em::DevicePolicyResponse* policy_copy = new em::DevicePolicyResponse;
   policy_copy->CopyFrom(policy);
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,
-      new PersistPolicyTask(backing_file_path_, policy_copy, now, false));
+      new PersistPolicyTask(backing_file_path_, policy_copy,
+                            base::Time::NowFromSystemTime()));
   return new_policy_differs;
 }
 
 DictionaryValue* DeviceManagementPolicyCache::GetPolicy() {
   AutoLock lock(lock_);
   return static_cast<DictionaryValue*>(policy_->DeepCopy());
 }
 
-void DeviceManagementPolicyCache::SetDeviceUnmanaged(bool is_device_unmanaged) {
-  if (is_device_unmanaged_ == is_device_unmanaged)
-    return;
-
-  is_device_unmanaged_ = is_device_unmanaged;
-  base::Time now(base::Time::NowFromSystemTime());
-  DictionaryValue* empty = new DictionaryValue();
-  {
-    AutoLock lock(lock_);
-    policy_.reset(empty);
-    last_policy_refresh_time_ = now;
-  }
-  BrowserThread::PostTask(
-      BrowserThread::FILE,
-      FROM_HERE,
-      new PersistPolicyTask(backing_file_path_,
-                            (is_device_unmanaged ? NULL
-                                : new em::DevicePolicyResponse()),
-                            now,
-                            is_device_unmanaged_));
-}
-
 // static
 Value* DeviceManagementPolicyCache::DecodeIntegerValue(
     google::protobuf::int64 value) {
   if (value < std::numeric_limits<int>::min() ||
       value > std::numeric_limits<int>::max()) {
     LOG(WARNING) << "Integer value " << value
                  << " out of numeric limits, ignoring.";
     return NULL;
   }
 
@@ skipping 96 matching lines @@
             DeviceManagementPolicyCache::DecodeValue(named_value->value());
         if (decoded_value)
           result->Set(named_value->name(), decoded_value);
       }
     }
   }
   return result;
 }
 
 }  // namespace policy