Attachment #443364 for bug #554270

Attachment #443364: Here is small patch which is implementing old maemo 5 ImageExpose API by using new gfxSharedImageSurface structure... for bug #554270

View | Details | Raw Unified | Return to bug 554270
Collapse All | Expand All





EXPORTS_mozilla/plugins = \
  BrowserStreamChild.h \
  BrowserStreamParent.h \
  ChildAsyncCall.h \
  ChildTimer.h \
  NPEventOSX.h \
  NPEventWindows.h \
  NPEventX11.h \
  NPImageExpose.h \
  NPEventMem.h \
  PluginIdentifierChild.h \
  PluginIdentifierParent.h \
  PluginInstanceChild.h \
  PluginInstanceParent.h \
  PluginMessageUtils.h \
  PluginModuleChild.h \
  PluginModuleParent.h \
  PluginProcessParent.h \

  $(NULL)

include $(topsrcdir)/config/config.mk
include $(topsrcdir)/ipc/chromium/chromium-config.mk
endif

include $(topsrcdir)/config/rules.mk

CXXFLAGS += $(TK_CFLAGS) $(MOZ_CAIRO_CFLAGS)

DEFINES += -DFORCE_PR_LOG





/* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 8 -*- */
/* vim: set sw=4 ts=8 et tw=80 ft=cpp : */
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (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.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is Mozilla Plugin App.
 *
 * The Initial Developer of the Original Code is
 *   The Mozilla Foundation.
 * Portions created by the Initial Developer are Copyright (C) 2010
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Oleg Romashin <romaxa@gmail.com>
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

#ifndef mozilla_dom_plugins_NPEventMem_h
#define mozilla_dom_plugins_NPEventMem_h 1

#include "npapi.h"

namespace mozilla {

namespace plugins {

struct NPRemoteMemEvent {
    NPImageData image;
};

}

}

namespace IPC {

template <>
struct ParamTraits<mozilla::plugins::NPRemoteMemEvent>     // synonym for XEvent
{
    typedef mozilla::plugins::NPRemoteMemEvent paramType;

    static void Write(Message* aMsg, const paramType& aParam)
    {
        aMsg->WriteBytes(&aParam, sizeof(paramType));
    }

    static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
    {
        const char* bytes = 0;

        if (!aMsg->ReadBytes(aIter, &bytes, sizeof(paramType))) {
            return false;
        }

        memcpy(aResult, bytes, sizeof(paramType));
        return true;
    }

    static void Log(const paramType& aParam, std::wstring* aLog)
    {
        // TODO
        aLog->append(L"(MemEvent)");
    }

};

} // namespace IPC


#endif // ifndef mozilla_dom_plugins_NPEventMem_h





/* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 8 -*- */
/* vim: set sw=4 ts=8 et tw=80 ft=cpp : */
/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (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.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is Mozilla Plugin App.
 *
 * The Initial Developer of the Original Code is
 *   The Mozilla Foundation.
 * Portions created by the Initial Developer are Copyright (C) 2010
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *   Oleg Romashin <romaxa@gmail.com>
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

#ifndef mozilla_dom_plugins_NPImageExpose_h
#define mozilla_dom_plugins_NPImageExpose_h 1

#include "npapi.h"

namespace mozilla {

namespace plugins {

struct NPRemoteImageExpose {
    NPImageExpose image;
};

}

}

namespace IPC {

template <>
struct ParamTraits<mozilla::plugins::NPRemoteImageExpose>     // synonym for XEvent
{
    typedef mozilla::plugins::NPRemoteImageExpose paramType;

    static void Write(Message* aMsg, const paramType& aParam)
    {
        aMsg->WriteBytes(&aParam, sizeof(paramType));
    }

    static bool Read(const Message* aMsg, void** aIter, paramType* aResult)
    {
        const char* bytes = 0;

        if (!aMsg->ReadBytes(aIter, &bytes, sizeof(paramType))) {
            return false;
        }

        memcpy(aResult, bytes, sizeof(paramType));
        return true;
    }

    static void Log(const paramType& aParam, std::wstring* aLog)
    {
        // TODO
        aLog->append(L"(MemEvent)");
    }

};

} // namespace IPC


#endif // ifndef mozilla_dom_plugins_NPImageExpose_h





include protocol PPluginStream;
include protocol PStreamNotify;

include "mozilla/plugins/PluginMessageUtils.h";

using NPError;
using NPRemoteWindow;
using NPRemoteEvent;
using NPRemoteImageExpose;
using NPRemoteMemEvent;
using NPRect;
using NPNURLVariable;
using NPCoordinateSpace;
using mozilla::plugins::NativeWindowHandle;

namespace mozilla {
namespace plugins {


child:
  rpc __delete__();

  rpc NPP_SetWindow(NPRemoteWindow window);

  // this message is not used on non-X platforms
  rpc NPP_GetValue_NPPVpluginNeedsXEmbed()
    returns (bool value, NPError result);
  rpc NPP_GetValue_NPPVpluginWindowlessLocalBool()
    returns (bool value, NPError result);
  rpc NPP_GetValue_NPPVpluginScriptableNPObject()
    returns (nullable PPluginScriptableObject value, NPError result);

  rpc NPP_SetValue_NPNVprivateModeBool(bool value) returns (NPError result);

  rpc NPP_HandleEvent(NPRemoteEvent event)
    returns (int16_t handled);
  // special cases where we need to a shared memory buffer
  rpc NPP_HandleEvent_Shmem(NPRemoteEvent event, Shmem buffer)
    returns (int16_t handled, Shmem rtnbuffer);
  // special cases where we need to a shared memory buffer maemo
  rpc NPP_ImageExpose_Shmem(NPRemoteImageExpose imageExpose, Shmem buffer)
    returns (int16_t handled);
  // special cases where we need an iosurface
  rpc NPP_HandleEvent_IOSurface(NPRemoteEvent event, uint32_t surfaceid)
    returns (int16_t handled);
  // special cases of HandleEvent to make mediating races simpler
  rpc Paint(NPRemoteEvent event)
    returns (int16_t handled);
  // this is only used on windows to forward WM_WINDOWPOSCHANGE
  async WindowPosChanged(NPRemoteEvent event);






    NS_RUNTIMEABORT("shouldn't be called on non-X11 platforms");
    return false;               // not reached

#endif
}

bool
PluginInstanceChild::AnswerNPP_GetValue_NPPVpluginWindowlessLocalBool(
    bool* needs, NPError* rv)
{
    AssertPluginThread();

    PRBool winlessLocal = 0;
    if (!mPluginIface->getvalue) {
        *rv = NPERR_GENERIC_ERROR;
    }
    else {
        *rv = mPluginIface->getvalue(GetNPP(), NPPVpluginWindowlessLocalBool,
                                     &winlessLocal);
    }
    *needs = winlessLocal;
    return true;
}

bool
PluginInstanceChild::AnswerNPP_GetValue_NPPVpluginScriptableNPObject(
                                          PPluginScriptableObjectChild** aValue,
                                          NPError* aResult)
{
    AssertPluginThread();

    NPObject* object = nsnull;
    NPError result = NPERR_GENERIC_ERROR;

                                                 Shmem* rtnmem)
{
    NS_RUNTIMEABORT("not reached.");
    *rtnmem = mem;
    return true;
}
#endif

bool
PluginInstanceChild::AnswerNPP_ImageExpose_Shmem(const NPRemoteImageExpose& imageExposeMem,
                                                 Shmem& mem,
                                                 int16_t* handled)
{
    PLUGIN_LOG_DEBUG_FUNCTION;
    AssertPluginThread();

    NPImageExpose imageExpose = imageExposeMem.image;
    imageExpose.data = (char*)mem.get<char>();

    NPEvent pluginEvent;
    XGraphicsExposeEvent& exposeEvent = pluginEvent.xgraphicsexpose;
    exposeEvent.type = GraphicsExpose;
    exposeEvent.display = 0;
    // Store imageExpose structure pointer as drawable member
    exposeEvent.drawable = (Drawable)&imageExpose;
    exposeEvent.x = imageExpose.x;
    exposeEvent.y = imageExpose.y;
    exposeEvent.width = imageExpose.width;
    exposeEvent.height = imageExpose.height;
    exposeEvent.count = 0;
    // information not set:
    exposeEvent.serial = 0;
    exposeEvent.send_event = False;
    exposeEvent.major_code = 0;
    exposeEvent.minor_code = 0;
    if (!mPluginIface->event) {
        *handled = false;
    } else {
        *handled = mPluginIface->event(&mData, reinterpret_cast<void*>(&exposeEvent));
    }
    return true;
}

#ifdef XP_MACOSX
bool
PluginInstanceChild::AnswerNPP_HandleEvent_IOSurface(const NPRemoteEvent& event,
                                                     const uint32_t &surfaceid,
                                                     int16_t* handled)
{
    PLUGIN_LOG_DEBUG_FUNCTION;
    AssertPluginThread();





                                             LPARAM lParam);
#endif

protected:
    virtual bool AnswerNPP_SetWindow(const NPRemoteWindow& window);

    virtual bool
    AnswerNPP_GetValue_NPPVpluginNeedsXEmbed(bool* needs, NPError* rv);

    virtual bool
    AnswerNPP_GetValue_NPPVpluginWindowlessLocalBool(bool* needs, NPError* rv);

    virtual bool
    AnswerNPP_GetValue_NPPVpluginScriptableNPObject(PPluginScriptableObjectChild** value,
                                                    NPError* result);

    virtual bool
    AnswerNPP_SetValue_NPNVprivateModeBool(const bool& value, NPError* result);

    virtual bool
    AnswerNPP_HandleEvent(const NPRemoteEvent& event, int16_t* handled);
    virtual bool
    AnswerNPP_HandleEvent_Shmem(const NPRemoteEvent& event, Shmem& mem, int16_t* handled, Shmem* rtnmem);
    virtual bool
    AnswerNPP_ImageExpose_Shmem(const NPRemoteImageExpose& imageExpose, Shmem& mem,
                                int16_t* handled);
    virtual bool
    AnswerNPP_HandleEvent_IOSurface(const NPRemoteEvent& event, const uint32_t& surface, int16_t* handled);

    NS_OVERRIDE
    virtual bool
    AnswerPaint(const NPRemoteEvent& event, int16_t* handled)
    {
        return AnswerNPP_HandleEvent(event, handled);
    }






#include "BrowserStreamParent.h"
#include "PluginModuleParent.h"
#include "PluginStreamParent.h"
#include "StreamNotifyParent.h"
#include "npfunctions.h"
#include "nsAutoPtr.h"
#include "mozilla/unused.h"
#include "gfxContext.h"
#include "gfxImageSurface.h"
#include "gfxSharedImageSurface.h"

static bool sNoClearTransPluginBuffer = getenv("MOZ_NO_CLEAR_PLUGIN_BUFFER") ? PR_TRUE : PR_FALSE;

#if defined(OS_WIN)
#include <windowsx.h>

// Plugin focus event for widget.
extern const PRUnichar* kOOPPPluginFocusEventId;
UINT gOOPPPluginFocusEvent =
    RegisterWindowMessage(kOOPPPluginFocusEventId);

    , mQuirks(0)
#if defined(XP_MACOSX)
    , mShWidth(0)
    , mShHeight(0)
    , mShColorSpace(nsnull)
    , mDrawingModel(NPDrawingModelCoreGraphics)
    , mIOSurface(nsnull)
#endif
    , mWinSize(0, 0)
    , mSharedImage(nsnull)
    , mIsTransparent(false)
{
    InitQuirksModes(aMimeType);
}

void
PluginInstanceParent::InitQuirksModes(const nsCString& aMimeType)
{
#ifdef OS_MACOSX

    return true;
}

bool
PluginInstanceParent::AnswerNPN_SetValue_NPPVpluginTransparent(
    const bool& transparent, NPError* result)
{
    NPBool isTransparent = transparent;
    mIsTransparent = transparent;
    *result = mNPNIface->setvalue(mNPP, NPPVpluginTransparentBool,
                                  (void*)isTransparent);
    return true;
}

bool
PluginInstanceParent::AnswerNPN_SetValue_NPPVpluginDrawingModel(
    const int& drawingModel, NPError* result)

    }
#endif

#if defined(MOZ_X11) && defined(XP_UNIX) && !defined(XP_MACOSX)
    const NPSetWindowCallbackStruct* ws_info =
      static_cast<NPSetWindowCallbackStruct*>(aWindow->ws_info);
    window.visualID = ws_info->visual ? ws_info->visual->visualid : None;
    window.colormap = ws_info->colormap;
    mWinSize.width = window.width;
    mWinSize.height = window.height;
#endif

    if (!CallNPP_SetWindow(window))
        return NPERR_GENERIC_ERROR;

    return NPERR_NO_ERROR;
}



        if (NPERR_NO_ERROR != rv) {
            return rv;
        }

        (*(NPBool*)_retval) = needsXEmbed;
        return NPERR_NO_ERROR;
    }

    case NPPVpluginWindowlessLocalBool: {
        bool winlessLocal;
        NPError rv;

        if (!CallNPP_GetValue_NPPVpluginWindowlessLocalBool(&winlessLocal, &rv)) {
            return NPERR_GENERIC_ERROR;
        }

        if (NPERR_NO_ERROR != rv) {
            return rv;
        }

        (*(NPBool*)_retval) = winlessLocal;
        return NPERR_NO_ERROR;
    }

#endif

    case NPPVpluginScriptableNPObject: {
        PPluginScriptableObjectParent* actor;
        NPError rv;
        if (!CallNPP_GetValue_NPPVpluginScriptableNPObject(&actor, &rv)) {
            return NPERR_GENERIC_ERROR;
        }

        NS_ERROR("Unhandled NPNVariable in NPP_SetValue");
        PR_LOG(gPluginLog, PR_LOG_WARNING,
               ("In PluginInstanceParent::NPP_SetValue: Unhandled NPNVariable %i (%s)",
                (int) variable, NPNVariableToString(variable)));
        return NPERR_GENERIC_ERROR;
    }
}

static inline gfxASurface::gfxImageFormat
_depth_to_gfxFormat(int depth)
{
    switch (depth) {
    case 32:
        return gfxASurface::ImageFormatARGB32;
    case 24:
        return gfxASurface::ImageFormatRGB24;
    case 16:
        return gfxASurface::ImageFormatRGB16_565;
    default:
        return gfxASurface::ImageFormatUnknown;
    }
}

int16_t
PluginInstanceParent::NPP_HandleEvent(void* event)
{
    PLUGIN_LOG_DEBUG_FUNCTION;

#if defined(XP_MACOSX)
    NPCocoaEvent* npevent = reinterpret_cast<NPCocoaEvent*>(event);
#else

                // or not, just returning 1 for good hygiene
                return 1;
            }
            break;
        }
    }
#endif

#if defined(MOZ_PLATFORM_MAEMO)
    if (npevent->type == GraphicsExpose && !npevent->xgraphicsexpose.display) {
        NPRemoteImageExpose npremoteimageexpose;
        // Take NPImageData structure from hacked XEvent drawable
        NPImageExpose *imgExp = (NPImageExpose*)npevent->xgraphicsexpose.drawable;
        npremoteimageexpose.image = *imgExp;
        // Plugin render stuff by using temporary surface
        NPRemoteImageExpose tempimgexpose;
        tempimgexpose.image = *imgExp;

        if (mIsTransparent)
            tempimgexpose.image.depth = 32;

        gfxASurface::gfxImageFormat fmt = _depth_to_gfxFormat(tempimgexpose.image.depth);

        if (!mSharedImage
            || mSharedImage->Width() != mWinSize.width
            || mSharedImage->Height() != mWinSize.height
            || mSharedImage->Format() != fmt) {
             delete mSharedImage;
             mSharedImage = new gfxSharedImageSurface(this, mWinSize, fmt);
        }
        if (mIsTransparent && !sNoClearTransPluginBuffer) {
            // Fill transparent plugins surface
            nsRefPtr<gfxContext> ctx = new gfxContext(mSharedImage);
            ctx->SetOperator(gfxContext::OPERATOR_CLEAR);
            ctx->Rectangle(gfxRect(imgExp->x, imgExp->y, imgExp->width, imgExp->height));
            ctx->Clip();
            ctx->Fill();
        }

        tempimgexpose.image.stride = mSharedImage->Stride();
        tempimgexpose.image.dataSize.width = mSharedImage->Width();
        tempimgexpose.image.dataSize.height = mSharedImage->Height();
        tempimgexpose.image.translateX = 0;
        tempimgexpose.image.translateY = 0;
        tempimgexpose.image.scaleX = 1;
        tempimgexpose.image.scaleY = 1;
        Shmem imagemem = mSharedImage->GetShmem();
        if (!CallNPP_ImageExpose_Shmem(tempimgexpose, imagemem, &handled)) {
            return false; // no good way to handle errors here...
        }
        // Get target gfx Context
        nsRefPtr<gfxImageSurface> surface =
            new gfxImageSurface((unsigned char*)imgExp->data,
                                gfxIntSize(imgExp->dataSize.width,
                                           imgExp->dataSize.height),
                                imgExp->stride,
                                _depth_to_gfxFormat(imgExp->depth));
        nsRefPtr<gfxContext> ctx = new gfxContext(surface);
        // Paint shm buffer to target surface
        ctx->SetOperator(mIsTransparent ? gfxContext::OPERATOR_OVER : gfxContext::OPERATOR_SOURCE);
        ctx->Translate(gfxPoint(imgExp->translateX, imgExp->translateY));
        ctx->Scale(imgExp->scaleX, imgExp->scaleY);
        ctx->SetSource(mSharedImage);
        nsRefPtr<gfxPattern> pat = ctx->GetPattern();
        pat->SetFilter(gfxPattern::FILTER_NEAREST);
        pat->SetExtend(gfxPattern::EXTEND_NONE);
        ctx->SetPattern(pat);
        ctx->Rectangle(gfxRect(imgExp->x, imgExp->y, imgExp->width, imgExp->height), PR_TRUE);
        ctx->Clip();
        ctx->Paint();
        return handled;
    }
#endif

#ifdef MOZ_X11
    switch (npevent->type) {
    case GraphicsExpose:
        PLUGIN_LOG_DEBUG(("  schlepping drawable 0x%lx across the pipe\n",
                          npevent->xgraphicsexpose.drawable));
        // Make sure the X server has created the Drawable and completes any
        // drawing before the plugin draws on top.
        //
        // XSync() waits for the X server to complete.  Really this parent





#endif

#include "npfunctions.h"
#include "nsAutoPtr.h"
#include "nsDataHashtable.h"
#include "nsHashKeys.h"
#include "nsRect.h"

class gfxSharedImageSurface;

namespace mozilla {
namespace plugins {

class PBrowserStreamParent;
class PluginModuleParent;

class PluginInstanceParent : public PPluginInstanceParent
{

private:
    Shmem              mShSurface; 
    size_t             mShWidth;
    size_t             mShHeight;
    CGColorSpaceRef    mShColorSpace;
    int16_t            mDrawingModel;
    nsIOSurface       *mIOSurface;
#endif // definied(OS_MACOSX)

    gfxIntSize         mWinSize;
    gfxSharedImageSurface *mSharedImage;
    bool               mIsTransparent;
};


} // namespace plugins
} // namespace mozilla

#endif // ifndef dom_plugins_PluginInstanceParent_h






RPCChannel::RacyRPCPolicy
MediateRace(const RPCChannel::Message& parent,
            const RPCChannel::Message& child)
{
  switch (parent.type()) {
  case PPluginInstance::Msg_Paint__ID:
  case PPluginInstance::Msg_NPP_SetWindow__ID:
  case PPluginInstance::Msg_NPP_ImageExpose_Shmem__ID:
  case PPluginInstance::Msg_NPP_HandleEvent_Shmem__ID:
  case PPluginInstance::Msg_NPP_HandleEvent_IOSurface__ID:
    // our code relies on the frame list not changing during paints and
    // reflows
    return RPCChannel::RRPParentWins;

  default:
    return RPCChannel::RRPChildWins;





  
        VARSTR(NPPVpluginWantsAllNetworkStreams);

#ifdef XP_MACOSX
        VARSTR(NPPVpluginDrawingModel);
        VARSTR(NPPVpluginEventModel);
#endif

        VARSTR(NPPVpluginWindowlessLocalBool);

    default: return "???";
    }
}

inline const char*
NPNVariableToString(NPNVariable aVar)
{
    switch(aVar) {



// Serializing NPEvents is completely platform-specific and can be rather
// intricate depending on the platform.  So for readability we split it
// into separate files and have the only macro crud live here.
// 
// NB: these guards are based on those where struct NPEvent is defined
// in npapi.h.  They should be kept in sync.
#  include "mozilla/plugins/NPImageExpose.h"
#  include "mozilla/plugins/NPEventMem.h"
#if defined(XP_MACOSX)
#  include "mozilla/plugins/NPEventOSX.h"
#elif defined(XP_WIN)
#  include "mozilla/plugins/NPEventWindows.h"
#elif defined(XP_OS2)
#  error Sorry, OS/2 is not supported
#elif defined(XP_UNIX) && defined(MOZ_X11)
#  include "mozilla/plugins/NPEventX11.h"

Return to bug 554270