android: Pass CPU properties from browser to renderer process.

content/public/android/java/src/org/chromium/content/app/SandboxedProcessService.java

 // 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.
 
 package org.chromium.content.app;
 
 import android.app.Service;
 import android.content.Context;
 import android.content.Intent;
 import android.graphics.SurfaceTexture;
@@ skipping 29 matching lines @@
 public class SandboxedProcessService extends Service {
     private static final String MAIN_THREAD_NAME = "SandboxedProcessMain";
     private static final String TAG = "SandboxedProcessService";
     private ISandboxedProcessCallback mCallback;
 
     // This is the native "Main" thread for the renderer / utility process.
     private Thread mSandboxMainThread;
     // Parameters received via IPC, only accessed while holding the mSandboxMainThread monitor.
     private String mNativeLibraryName;  // Must be passed in via the bind command.
     private String[] mCommandLineParams;
+    private int mCpuCount;
+    private long mCpuFeatures;
     // Pairs IDs and file descriptors that should be registered natively.
     private ArrayList<Integer> mFileIds;
     private ArrayList<ParcelFileDescriptor> mFileFds;
 
     private static Context sContext = null;
     private boolean mLibraryInitialized = false;
 
     // Binder object used by clients for this service.
     private final ISandboxedProcessService.Stub mBinder = new ISandboxedProcessService.Stub() {
         // NOTE: Implement any ISandboxedProcessService methods here.
         @Override
         public int setupConnection(Bundle args, ISandboxedProcessCallback callback) {
             mCallback = callback;
             synchronized (mSandboxMainThread) {
                 // Allow the command line to be set via bind() intent or setupConnection, but
                 // the FD can only be transferred here.
                 if (mCommandLineParams == null) {
                     mCommandLineParams = args.getStringArray(
                             SandboxedProcessConnection.EXTRA_COMMAND_LINE);
                 }
                 // We must have received the command line by now
                 assert mCommandLineParams != null;
+                mCpuCount = args.getInt(SandboxedProcessConnection.EXTRA_CPU_COUNT);
+                mCpuFeatures = args.getLong(SandboxedProcessConnection.EXTRA_CPU_FEATURES);
+                assert mCpuCount > 0;
                 mFileIds = new ArrayList<Integer>();
                 mFileFds = new ArrayList<ParcelFileDescriptor>();
                 for (int i = 0;; i++) {
                     String fdName = SandboxedProcessConnection.EXTRA_FILES_PREFIX + i
                             + SandboxedProcessConnection.EXTRA_FILES_FD_SUFFIX;
                     ParcelFileDescriptor parcel = args.getParcelable(fdName);
                     if (parcel == null) {
                         // End of the file list.
                         break;
                     }
@@ skipping 53 matching lines @@
                     }
                     assert mFileIds.size() == mFileFds.size();
                     int[] fileIds = new int[mFileIds.size()];
                     int[] fileFds = new int[mFileFds.size()];
                     for (int i = 0; i < mFileIds.size(); ++i) {
                         fileIds[i] = mFileIds.get(i);
                         fileFds[i] = mFileFds.get(i).detachFd();
                     }
                     ContentMain.initApplicationContext(sContext.getApplicationContext());
                     nativeInitSandboxedProcess(sContext.getApplicationContext(),
-                            SandboxedProcessService.this, fileIds, fileFds);
+                            SandboxedProcessService.this, fileIds, fileFds,
+                            mCpuCount, mCpuFeatures);
                     ContentMain.start();
                     nativeExitSandboxedProcess();
                 } catch (InterruptedException e) {
                     Log.w(TAG, MAIN_THREAD_NAME + " startup failed: " + e);
                 }
             }
         }, MAIN_THREAD_NAME);
         mSandboxMainThread.start();
     }
 
@@ skipping 86 matching lines @@
      * The main entry point for a sandboxed process. This should be called from a new thread since
      * it will not return until the sandboxed process exits. See sandboxed_process_service.{h,cc}
      *
      * @param applicationContext The Application Context of the current process.
      * @param service The current SandboxedProcessService object.
      * @param fileIds A list of file IDs that should be registered for access by the renderer.
      * @param fileFds A list of file descriptors that should be registered for access by the
      * renderer.
      */
     private static native void nativeInitSandboxedProcess(Context applicationContext,
-            SandboxedProcessService service, int[] extraFileIds, int[] extraFileFds);
+            SandboxedProcessService service, int[] extraFileIds, int[] extraFileFds,
+            int cpuCount, long cpuFeatures);
 
     /**
      * Force the sandboxed process to exit.
      */
     private static native void nativeExitSandboxedProcess();
 
     private native void nativeShutdownSandboxMainThread();
 }