Merge commit 'goog/master_gl' into merge_master_gl (dcab005f) · Commits · e / os / android_frameworks_native

include/binder/IServiceManager.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -78,6 +78,8 @@ status_t getService(const String16& name, sp<INTERFACE>* outService)
		bool checkCallingPermission(const String16& permission);
		bool checkCallingPermission(const String16& permission,
		int32_t* outPid, int32_t* outUid);
		bool checkPermission(const String16& permission, pid_t pid, uid_t uid);


		// ----------------------------------------------------------------------

include/binder/MemoryDealer.h

+12 −3

Original line number	Diff line number	Diff line
		@@ -126,13 +126,22 @@ public:
		mFirst = mLast = newNode;
		newNode->prev = newNode->next = 0;
		} else {
		insertBefore(mFirst, newNode);
		newNode->prev = 0;
		newNode->next = mFirst;
		mFirst->prev = newNode;
		mFirst = newNode;
		}
		}

		void insertTail(NODE* newNode) {
		if (mLast == 0) insertBeginning(newNode);
		else insertAfter(mLast, newNode);
		if (mLast == 0) {
		insertHead(newNode);
		} else {
		newNode->prev = mLast;
		newNode->next = 0;
		mLast->next = newNode;
		mLast = newNode;
		}
		}

		NODE* remove(NODE* node) {

include/binder/Permission.h

0 → 100644

+68 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2009 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#ifndef BINDER_PERMISSION_H
		#define BINDER_PERMISSION_H

		#include <stdint.h>
		#include <unistd.h>

		#include <utils/SortedVector.h>
		#include <utils/String16.h>
		#include <utils/threads.h>

		namespace android {
		// ---------------------------------------------------------------------------

		/*
		* Permission caches the result of the permission check for the given
		* permission name and the provided uid/pid. It also handles a few
		* known cases efficiently (caller is in the same process or is root).
		* The package manager does something similar but lives in dalvik world
		* and is therefore extremely slow to access.
		*/

		class Permission
		{
		public:
		Permission(char const* name);
		Permission(const String16& name);
		Permission(const Permission& rhs);
		virtual ~Permission();

		bool operator < (const Permission& rhs) const;

		// checks the current binder call's caller has access to this permission
		bool checkCalling() const;

		// checks the specified pid/uid has access to this permission
		bool check(pid_t pid, uid_t uid) const;

		protected:
		virtual bool doCheckPermission(pid_t pid, uid_t uid) const;

		private:
		Permission& operator = (const Permission& rhs) const;
		const String16 mPermissionName;
		mutable SortedVector<uid_t> mGranted;
		const pid_t mPid;
		mutable Mutex mLock;
		};

		// ---------------------------------------------------------------------------
		}; // namespace android

		#endif /* BINDER_PERMISSION_H */

include/private/opengles/gl_context.h

+30 −12

Original line number	Diff line number	Diff line
		@@ -26,6 +26,8 @@
		#endif

		#include <private/pixelflinger/ggl_context.h>
		#include <hardware/copybit.h>
		#include <hardware/gralloc.h>

		#include <GLES/gl.h>
		#include <GLES/glext.h>
		@@ -594,6 +596,14 @@ struct prims_t {
		void (renderTriangle)(GL, vertex_t, vertex_t, vertex_t);
		};

		struct copybits_context_t {
		// A handle to the blit engine, if it exists, else NULL.
		copybit_device_t* blitEngine;
		int32_t minScale;
		int32_t maxScale;
		buffer_handle_t drawSurfaceBuffer;
		};

		struct ogles_context_t {
		context_t rasterizer;
		array_machine_t arrays __attribute__((aligned(32)));
		@@ -617,6 +627,14 @@ struct ogles_context_t {
		uint32_t transformTextures : 1;
		EGLSurfaceManager* surfaceManager;
		EGLBufferObjectManager* bufferObjectManager;

		// copybits is only used if LIBAGL_USE_GRALLOC_COPYBITS is
		// defined, but it is always present because ogles_context_t is a public
		// struct that is used by clients of libagl. We want the size and offsets
		// to stay the same, whether or not LIBAGL_USE_GRALLOC_COPYBITS is defined.

		copybits_context_t copybits;

		GLenum error;

		static inline ogles_context_t* get() {

include/private/ui/RegionHelper.h

0 → 100644

+279 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2009 The Android Open Source Project
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/

		#ifndef ANDROID_UI_PRIVATE_REGION_HELPER_H
		#define ANDROID_UI_PRIVATE_REGION_HELPER_H

		#include <stdint.h>
		#include <sys/types.h>

		namespace android {
		// ----------------------------------------------------------------------------

		template<typename RECT>
		class region_operator
		{
		typedef typename RECT::value_type TYPE;
		static const TYPE max_value = 0x7FFFFFF;

		public:
		/*
		* Common boolean operations:
		* value is computed as 0b101 op 0b110
		* other boolean operation are possible, simply compute
		* their corresponding value with the above formulae and use
		* it when instantiating a region_operator.
		*/
		static const uint32_t LHS = 0x5; // 0b101
		static const uint32_t RHS = 0x6; // 0b110
		enum {
		op_nand = LHS & ~RHS,
		op_and = LHS & RHS,
		op_or = LHS \| RHS,
		op_xor = LHS ^ RHS
		};

		struct region {
		RECT const* rects;
		size_t count;
		TYPE dx;
		TYPE dy;
		inline region(const region& rhs)
		: rects(rhs.rects), count(rhs.count), dx(rhs.dx), dy(rhs.dy) { }
		inline region(RECT const* r, size_t c)
		: rects(r), count(c), dx(), dy() { }
		inline region(RECT const* r, size_t c, TYPE dx, TYPE dy)
		: rects(r), count(c), dx(dx), dy(dy) { }
		};

		class region_rasterizer {
		friend class region_operator;
		virtual void operator()(const RECT& rect) = 0;
		};

		inline region_operator(int op, const region& lhs, const region& rhs)
		: op_mask(op), spanner(lhs, rhs)
		{
		}

		void operator()(region_rasterizer& rasterizer) {
		RECT current;
		do {
		SpannerInner spannerInner(spanner.lhs, spanner.rhs);
		int inside = spanner.next(current.top, current.bottom);
		spannerInner.prepare(inside);
		do {
		TYPE left, right;
		int inside = spannerInner.next(current.left, current.right);
		if ((op_mask >> inside) & 1) {
		if (current.left < current.right &&
		current.top < current.bottom) {
		rasterizer(current);
		}
		}
		} while(!spannerInner.isDone());
		} while(!spanner.isDone());
		}

		private:
		uint32_t op_mask;

		class SpannerBase
		{
		public:
		enum {
		lhs_before_rhs = 0,
		lhs_after_rhs = 1,
		lhs_coincide_rhs = 2
		};

		protected:
		TYPE lhs_head;
		TYPE lhs_tail;
		TYPE rhs_head;
		TYPE rhs_tail;

		inline int next(TYPE& head, TYPE& tail,
		bool& more_lhs, bool& more_rhs)
		{
		int inside;
		more_lhs = false;
		more_rhs = false;
		if (lhs_head < rhs_head) {
		inside = lhs_before_rhs;
		head = lhs_head;
		if (lhs_tail <= rhs_head) {
		tail = lhs_tail;
		more_lhs = true;
		} else {
		lhs_head = rhs_head;
		tail = rhs_head;
		}
		} else if (rhs_head < lhs_head) {
		inside = lhs_after_rhs;
		head = rhs_head;
		if (rhs_tail <= lhs_head) {
		tail = rhs_tail;
		more_rhs = true;
		} else {
		rhs_head = lhs_head;
		tail = lhs_head;
		}
		} else {
		inside = lhs_coincide_rhs;
		head = lhs_head;
		if (lhs_tail <= rhs_tail) {
		tail = rhs_head = lhs_tail;
		more_lhs = true;
		}
		if (rhs_tail <= lhs_tail) {
		tail = lhs_head = rhs_tail;
		more_rhs = true;
		}
		}
		return inside;
		}
		};

		class Spanner : protected SpannerBase
		{
		friend class region_operator;
		region lhs;
		region rhs;

		public:
		inline Spanner(const region& lhs, const region& rhs)
		: lhs(lhs), rhs(rhs)
		{
		SpannerBase::lhs_head = lhs.rects->top + lhs.dy;
		SpannerBase::lhs_tail = lhs.rects->bottom + lhs.dy;
		SpannerBase::rhs_head = rhs.rects->top + rhs.dy;
		SpannerBase::rhs_tail = rhs.rects->bottom + rhs.dy;
		}

		inline bool isDone() const {
		return !rhs.count && !lhs.count;
		}

		inline int next(TYPE& top, TYPE& bottom)
		{
		bool more_lhs = false;
		bool more_rhs = false;
		int inside = SpannerBase::next(top, bottom, more_lhs, more_rhs);
		if (more_lhs) {
		advance(lhs, SpannerBase::lhs_head, SpannerBase::lhs_tail);
		}
		if (more_rhs) {
		advance(rhs, SpannerBase::rhs_head, SpannerBase::rhs_tail);
		}
		return inside;
		}

		private:
		static inline
		void advance(region& reg, TYPE& aTop, TYPE& aBottom) {
		// got to next span
		size_t count = reg.count;
		RECT const * rects = reg.rects;
		RECT const * const end = rects + count;
		const int top = rects->top;
		while (rects != end && rects->top == top) {
		rects++;
		count--;
		}
		if (rects != end) {
		aTop = rects->top + reg.dy;
		aBottom = rects->bottom + reg.dy;
		} else {
		aTop = max_value;
		aBottom = max_value;
		}
		reg.rects = rects;
		reg.count = count;
		}
		};

		class SpannerInner : protected SpannerBase
		{
		region lhs;
		region rhs;

		public:
		inline SpannerInner(const region& lhs, const region& rhs)
		: lhs(lhs), rhs(rhs)
		{
		}

		inline void prepare(int inside) {
		SpannerBase::lhs_head = lhs.rects->left + lhs.dx;
		SpannerBase::lhs_tail = lhs.rects->right + lhs.dx;
		SpannerBase::rhs_head = rhs.rects->left + rhs.dx;
		SpannerBase::rhs_tail = rhs.rects->right + rhs.dx;
		if (inside == SpannerBase::lhs_before_rhs) {
		SpannerBase::rhs_head = max_value;
		SpannerBase::rhs_tail = max_value;
		} else if (inside == SpannerBase::lhs_after_rhs) {
		SpannerBase::lhs_head = max_value;
		SpannerBase::lhs_tail = max_value;
		} else {
		// use both spans
		}
		}

		inline bool isDone() const {
		return SpannerBase::lhs_head == max_value &&
		SpannerBase::rhs_head == max_value;
		}

		inline int next(TYPE& left, TYPE& right)
		{
		bool more_lhs = false;
		bool more_rhs = false;
		int inside = SpannerBase::next(left, right, more_lhs, more_rhs);
		if (more_lhs) {
		advance(lhs, SpannerBase::lhs_head, SpannerBase::lhs_tail);
		}
		if (more_rhs) {
		advance(rhs, SpannerBase::rhs_head, SpannerBase::rhs_tail);
		}
		return inside;
		}

		private:
		static inline
		void advance(region& reg, TYPE& left, TYPE& right) {
		if (reg.rects && reg.count) {
		const int cur_span_top = reg.rects->top;
		reg.rects++;
		reg.count--;
		if (!reg.count \|\| reg.rects->top != cur_span_top) {
		left = max_value;
		right = max_value;
		} else {
		left = reg.rects->left + reg.dx;
		right = reg.rects->right + reg.dx;
		}
		}
		}
		};

		Spanner spanner;
		};

		// ----------------------------------------------------------------------------
		};

		#endif /* ANDROID_UI_PRIVATE_REGION_HELPER_H */