Move AppRestriction to Policy code out of //chrome

chrome/browser/android/policy/policy_manager.cc

 // 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.
 
 #include "chrome/browser/android/policy/policy_manager.h"
 
 #include "base/android/jni_android.h"
-#include "base/android/jni_array.h"
-#include "base/android/jni_string.h"
-#include "base/bind.h"
-#include "base/json/json_reader.h"
-#include "base/prefs/pref_service.h"
-#include "base/strings/string_number_conversions.h"
 #include "chrome/browser/browser_process.h"
-#include "chrome/browser/profiles/profile_manager.h"
-#include "chrome/common/pref_names.h"
+#include "chrome/browser/browser_process_platform_part.h"
+#include "components/policy/core/browser/android/policy_converter.h"
 #include "components/policy/core/browser/browser_policy_connector.h"
 #include "components/policy/core/common/policy_provider_android.h"
+#include "components/policy/core/common/schema.h"
 #include "jni/PolicyManager_jni.h"
 
 using base::android::AttachCurrentThread;
-using base::android::ConvertJavaStringToUTF8;
+using base::android::ScopedJavaLocalRef;
 
 PolicyManager::PolicyManager(JNIEnv* env, jobject obj)
-    : weak_java_policy_manager_(env, obj),
-      policy_bundle_(new policy::PolicyBundle) {
+    : weak_java_policy_manager_(env, obj) {
   policy_provider_ = static_cast<policy::PolicyProviderAndroid*>(
       g_browser_process->browser_policy_connector()->GetPlatformProvider());
   policy_provider_->SetDelegate(this);
 }
 
 PolicyManager::~PolicyManager() {}
 
+ScopedJavaLocalRef<jobject> PolicyManager::CreatePolicyConverter(JNIEnv* env,
+                                                                 jobject obj) {
+  policy_converter_.reset(new policy::android::PolicyConverter(
+      policy_provider_->GetChromeSchema()));
+  return ScopedJavaLocalRef<jobject>(policy_converter_->GetJavaObject());
+}
+
 void PolicyManager::RefreshPolicies() {
   JNIEnv* env = AttachCurrentThread();
   Java_PolicyManager_refreshPolicies(
       env, weak_java_policy_manager_.get(env).obj());
 }
 
 void PolicyManager::PolicyProviderShutdown() {
-  policy_provider_ = NULL;
-}
-
-void PolicyManager::SetPolicyBoolean(JNIEnv* env,
-                                     jobject obj,
-                                     jstring policyKey,
-                                     jboolean value) {
-  SetPolicyValue(ConvertJavaStringToUTF8(env, policyKey),
-                 new base::FundamentalValue(static_cast<bool>(value)));
-}
-
-void PolicyManager::SetPolicyInteger(JNIEnv* env,
-                                     jobject obj,
-                                     jstring policyKey,
-                                     jint value) {
-  SetPolicyValue(ConvertJavaStringToUTF8(env, policyKey),
-                 new base::FundamentalValue(static_cast<int>(value)));
-}
-
-void PolicyManager::SetPolicyString(JNIEnv* env,
-                                    jobject obj,
-                                    jstring policyKey,
-                                    jstring value) {
-  SetPolicyValue(ConvertJavaStringToUTF8(env, policyKey),
-                 new base::StringValue(ConvertJavaStringToUTF8(env, value)));
-}
-
-void PolicyManager::SetPolicyStringArray(JNIEnv* env,
-                                         jobject obj,
-                                         jstring policyKey,
-                                         jobjectArray array) {
-  std::vector<base::string16> string_vector;
-  base::android::AppendJavaStringArrayToStringVector(env, array,
-                                                     &string_vector);
-  base::ListValue* list_values = new base::ListValue();
-  list_values->AppendStrings(string_vector);
-  SetPolicyValue(ConvertJavaStringToUTF8(env, policyKey), list_values);
+  policy_provider_ = nullptr;
 }
 
 void PolicyManager::FlushPolicies(JNIEnv* env, jobject obj) {
   if (!policy_provider_)
     return;
 
-  policy_provider_->SetPolicies(policy_bundle_.Pass());
-  policy_bundle_.reset(new policy::PolicyBundle);
+  policy_provider_->SetPolicies(policy_converter_->GetPolicyBundle());
 }
 
 void PolicyManager::Destroy(JNIEnv* env, jobject obj) {
   if (policy_provider_)
-    policy_provider_->SetDelegate(NULL);
+    policy_provider_->SetDelegate(nullptr);
 
   delete this;
 }
 
-// static
-base::Value* PolicyManager::ConvertValueToSchema(base::Value* raw_value,
-                                                 const policy::Schema& schema) {
-  scoped_ptr<base::Value> value(raw_value);
-
-  if (!schema.valid())
-    return value.release();
-
-  switch (schema.type()) {
-    case base::Value::TYPE_NULL:
-      return base::Value::CreateNullValue().release();
-
-    case base::Value::TYPE_BOOLEAN: {
-      std::string string_value;
-      if (value->GetAsString(&string_value)) {
-        if (string_value.compare("true") == 0)
-          return new base::FundamentalValue(true);
-
-        if (string_value.compare("false") == 0)
-          return new base::FundamentalValue(false);
-
-        return value.release();
-      }
-      int int_value = 0;
-      if (value->GetAsInteger(&int_value))
-        return new base::FundamentalValue(int_value != 0);
-
-      return value.release();
-    }
-
-    case base::Value::TYPE_INTEGER: {
-      std::string string_value;
-      if (value->GetAsString(&string_value)) {
-        int int_value = 0;
-        if (base::StringToInt(string_value, &int_value))
-          return new base::FundamentalValue(int_value);
-      }
-      return value.release();
-    }
-
-    case base::Value::TYPE_DOUBLE: {
-      std::string string_value;
-      if (value->GetAsString(&string_value)) {
-        double double_value = 0;
-        if (base::StringToDouble(string_value, &double_value))
-          return new base::FundamentalValue(double_value);
-      }
-      return value.release();
-    }
-
-    // String can't be converted from other types.
-    case base::Value::TYPE_STRING: {
-      return value.release();
-    }
-
-    // Binary is not a valid schema type.
-    case base::Value::TYPE_BINARY: {
-      NOTREACHED();
-      return NULL;
-    }
-
-    // Complex types have to be deserialized from JSON.
-    case base::Value::TYPE_DICTIONARY:
-    case base::Value::TYPE_LIST: {
-      std::string string_value;
-      if (value->GetAsString(&string_value)) {
-        scoped_ptr<base::Value> decoded_value =
-            base::JSONReader::Read(string_value);
-        if (decoded_value)
-          return decoded_value.release();
-      }
-      return value.release();
-    }
-  }
-
-  NOTREACHED();
-  return NULL;
-}
-
-void PolicyManager::SetPolicyValue(const std::string& key, base::Value* value) {
-  if (!policy_provider_)
-    return;
-
-  policy::Schema schema =
-      policy_provider_->GetChromeSchema()->GetKnownProperty(key);
-
-  policy::PolicyNamespace ns(policy::POLICY_DOMAIN_CHROME, std::string());
-  policy_bundle_->Get(ns).Set(key,
-                              policy::POLICY_LEVEL_MANDATORY,
-                              policy::POLICY_SCOPE_MACHINE,
-                              ConvertValueToSchema(value, schema),
-                              NULL);
-}
-
 static jlong Init(JNIEnv* env, jobject obj) {
   return reinterpret_cast<intptr_t>(new PolicyManager(env, obj));
 }
 
 bool RegisterPolicyManager(JNIEnv* env) {
   return RegisterNativesImpl(env);
 }