Am I computing the attributes of my frustum properly?

Question

I have a basic camera class, of which has the following notable functions:

    // Get near and far plane dimensions in view space coordinates.
float GetNearWindowWidth()const;
float GetNearWindowHeight()const;
float GetFarWindowWidth()const;
float GetFarWindowHeight()const;

// Set frustum.
void SetLens(float fovY, float aspect, float zn, float zf);

Where the params zn and zf in the SetLens function correspond to the near and far clip plane distance, respectively.

SetLens basically creates a perspective projection matrix, along with computing both the far and near clip plane's height:

void Camera::SetLens(float fovY, float aspect, float zn, float zf)
{
    // cache properties
    mFovY = fovY;
    mAspect = aspect;
    mNearZ = zn;
    mFarZ = zf;

    float tanHalfFovy = tanf( 0.5f * glm::radians( fovY ) );

    mNearWindowHeight = 2.0f * mNearZ * tanHalfFovy;
    mFarWindowHeight  = 2.0f * mFarZ * tanHalfFovy;

    mProj = glm::perspective( fovY, aspect, zn, zf );
}

So, GetFarWindowHeight() and GetNearWindowHeight() naturally return their respective height class member values. Their width counterparts, however, return the respective height value multiplied by the view aspect ratio. So, for GetNearWindowWidth():

float Camera::GetNearWindowWidth()const
{
    return mAspect * mNearWindowHeight;
}  

Where GetFarWindowWidth() performs the same computation, of course replacing mNearWindowHeight with mFarWindowHeight.

Now that's all out of the way, something tells me that I'm computing the height and width of the near and far clip planes improperly. In particular, I think what causes this confusion is the fact that I'm specifying the field of view on the y axis in degrees, and then converting it to radians in the tangent function. Where I think this is causing problems is in my frustum culling function, which uses the width/height of the near and far planes to obtain points for the top, right, left and bottom planes as well.

So, am I correct in that I'm doing this completely wrong? If so, what should I do to fix it?

Disclaimer

This code originally stems from a D3D11 book, which I decided to quit reading and move back to OpenGL. In order to make the process less painful, I figured converting some of the original code to be more OpenGL compliant would be nice. So far, it's worked fairly well, with this one minor issue...

Edit

I should have originally mentioned a few things:

• This is not my first time with OpenGL; I'm well aware of the transformation processes, as well the as the coordinate system differences between GL and D3D.

• This isn't my entire camera class, although the only other thing which I think may be questionable in this context is using my camera's mOrientation matrix to compute the look, up, and right direction vectors, via transforming each on a +x, +y, and -z basis, respectively. So, as an example, to compute my look vector I would do: mOrientation * vec4(0.0f, 0.0f, -1.0f, 1.0f), and then convert that to a vec3. The context that I'm referring to here involves how these basis vectors would be used in conjunction with culling the frustum.